java什么情况下会锁表(java锁的可见性的是怎么保证的)
各位老铁们，大家好，今天由我来为大家分享java什么情况下会锁表，以及java锁的可见性的是怎么保证的的相关问题知识，希望对大家有所帮助。如果可以帮助到大家，还望关注收藏下本站，您的支持是我们最大的动力，谢谢大家了哈，下面我们开始吧！
java锁的可见性的是怎么保证的
单例类在Java开发者中非常常用，但是它给初级开发者们造成了很多挑战。他们所面对的其中一个关键挑战是，怎样确保单例类的行为是单例？也就是说，无论任何原因，如何防止单例类有多个实例。在整个应用生命周期中，要保证只有一个单例类的实例被创建，双重检查锁（Double checked locking of Singleton）是一种实现方法。顾名思义，在双重检查锁中，代码会检查两次单例类是否有已存在的实例，一次加锁一次不加锁，一次确保不会有多个实例被创建。顺便提一下，在JDK1.5中，Java修复了其内存模型的问题。在JDK1.5之前，这种方法会有问题。本文中，我们将会看到怎样用Java实现双重检查锁的单例类，为什么Java 5之前的版本双重检查锁会有问题，以及怎么解决这个问题。顺便说一下，这也是重要的面试要点，我曾经在金融业和服务业的公司面试被要求手写双重检查锁实现单例模式、相信我，这很棘手，除非你清楚理解了你在做什么。你也可以阅读我的完整列表“单例模式设计问题”来更好的准备面试。
为什么你需要双重检查锁来实现单例类？
一个常见情景，单例类在多线程环境中违反契约。如果你要一个新手写出单例模式，可能会得到下面的代码：
private static Singleton _instance;
public static Singleton getInstance(){
if(_instance== null){
_instance= new Singleton();
}
return _instance;
}
然后，当你指出这段代码在超过一个线程并行被调用的时候会创建多个实例的问题时，他很可能会把整个getInstance()方法设为同步（synchronized），就像我们展示的第二段示例代码getInstanceTS()方法一样。尽管这样做到了线程安全，并且解决了多实例问题，但并不高效。在任何调用这个方法的时候，你都需要承受同步带来的性能开销，然而同步只在第一次调用的时候才被需要，也就是单例类实例创建的时候。这将促使我们使用双重检查锁模式（double checked locking pattern），一种只在临界区代码加锁的方法。程序员称其为双重检查锁，因为会有两次检查 _instance== null，一次不加锁，另一次在同步块上加锁。这就是使用Java双重检查锁的示例：
public static Singleton getInstanceDC(){
if(_instance== null){// Single Checked
synchronized(Singleton.class){
if(_instance== null){// Double checked
_instance= new Singleton();
}
}
}
return _instance;
}
这个方法表面上看起来很完美，你只需要付出一次同步块的开销，但它依然有问题。除非你声明_instance变量时使用了volatile关键字。没有volatile修饰符，可能出现Java中的另一个线程看到个初始化了一半的_instance的情况，但使用了volatile变量后，就能保证先行发生关系（happens-before relationship）。对于volatile变量_instance，所有的写（write）都将先行发生于读（read），在Java 5之前不是这样，所以在这之前使用双重检查锁有问题。现在，有了先行发生的保障（happens-before guarantee），你可以安全地假设其会工作良好。另外，这不是创建线程安全的单例模式的最好方法，你可以使用枚举实现单例模式，这种方法在实例创建时提供了内置的线程安全。另一种方法是使用静态持有者模式（static holder pattern）。
/*
* A journey to write double checked locking of Singleton class in Java.
*/
class Singleton{
private volatile static Singleton _instance;
private Singleton(){
// preventing Singleton object instantiation from outside
}
/*
* 1st version: creates multiple instance if two thread access
* this method simultaneously
*/
public static Singleton getInstance(){
if(_instance== null){
_instance= new Singleton();
}
return _instance;
}
/*
* 2nd version: this definitely thread-safe and only
* creates one instance of Singleton on concurrent environment
* but unnecessarily expensive due to cost of synchronization
* at every call.
*/
public static synchronized Singleton getInstanceTS(){
if(_instance== null){
_instance= new Singleton();
}
return _instance;
}
/*
* 3rd version: An implementation of double checked locking of Singleton.
* Intention is to minimize cost of synchronization and improve performance,
* by only locking critical section of code, the code which creates instance of Singleton class.
* By the way this is still broken, if we don't make _instance volatile, as another thread can
* see a half initialized instance of Singleton.
*/
public static Singleton getInstanceDC(){
if(_instance== null){
synchronized(Singleton.class){
if(_instance== null){
_instance= new Singleton();
}
}
}
return _instance;
}
}
这就是本文的所有内容了。这是个用Java创建线程安全单例模式的有争议的方法，使用枚举实现单例类更简单有效。我并不建议你像这样实现单例模式，因为用Java有许多更好的方式。但是，这个问题有历史意义，也教授了并发是如何引入一些微妙错误的。正如之前所说，这是面试中非常重要的一点。在去参加任何Java面试之前，要练习手写双重检查锁实现单例类。这将增强你发现Java程序员们所犯编码错误的洞察力。另外，在现在的测试驱动开发中，单例模式由于难以被模拟其行为而被视为反模式（anti pattern），所以如果你是测试驱动开发的开发者，最好避免使用单例模式。
java程序中如何实现对mysql数据库中表的锁定
方法1：用mysql命令锁住表.
publicvoidtest(){
Stringsql="locktablesaa1write";
//或Stringsql="locktablesaa1read";
//如果想锁多个表locktablesaa1read,aa2write,.....
Stringsql1="select*fromaa1";
Stringsql2="unlocktables";
try{
this.pstmt=conn.prepareStatement(sql);
this.pstmt1=conn.prepareStatement(sql1);
this.pstmt2=conn.prepareStatement(sql2);
pstmt.executeQuery();
pstmt1.executeQuery();
pstmt2.executeQuery();
}catch(Exceptione){
System.out.println("异常"+e.getMessage());
}
}
对于read lock和 write lock官方说明：
1.如果一个线程获得一个表的READ锁定，该线程（和所有其它线程）只能从该表中读取。
如果一个线程获得一个表的WRITE锁定，只有保持锁定的线程可以对表进行写入。
其它的线程被阻止，直到锁定被释放时为止。
2.当您使用LOCK TABLES时，您必须锁定您打算在查询中使用的所有的表。
虽然使用LOCKTABLES语句获得的锁定仍然有效，但是您不能访问没有被此语句锁定的任何的表。
同时，您不能在一次查询中多次使用一个已锁定的表——使用别名代替，
在此情况下，您必须分别获得对每个别名的锁定。
对与read lock和 write lock个人说明：
1.read lock和 write lock是线程级(表级别).
2.在同一个会话中加了read lock锁.只能对这个表进行读操作.对这个表以外的任何表都无法进行增、删、改、查的操作.
但是在不同会话中，只能对加了read lock的表进行读操作.但可以对read lock以外的表进行增、删、改、查的操作.
3.在同一个会话中加了write lock锁.只能对这个表进行读、写操作.对这个表以外的任何表都无法进行增、删、改、查的操作.
但是在不同会话中,无法对加了write lock的表进行读、写操作.但可以对write lock以外的表进行增、删、改、查的操作.
4.如果表中使用了别名.(SELECT* FROM aa1 AS byname_table)
在对aa1加锁时，必须把别名加上去(lock tables aa1 as byname_table read)
在同一个会话中.必须使用别名进行查询.
在不同的会话中.可以不需要使用别名进行查询.
5.在多个会话中可以对同一个表进行lock read操作.但不能在多个会话中对同一个表进行lock write操作（这些锁将等待已锁的表释放自身的线程锁）
如果多个会话对同一个表进行lock read操作.那么在这些会话中,也只能对以锁的表进行读操作.
6.如果要你锁住了一个表，需要嵌套查询.你必须使用别名，并且，要锁定别名.
例如.lock table aa1 read,aa1 as byname_table read;
select* from aa1 where id in(select* from aa1 as xxwhere id=2);
7.解锁必须用unlock tables;
另:
在JAVA程序中,要想解锁,需要调用 unlock tables来解锁.
如果没有调用unlock tables.
关闭connection、程序结束、调用GC都能解锁.
方法2：用记录锁锁表.
publicvoidtest(){
Stringsql="select*fromaa1forupdate";
//select*fromaa1lockinsharemode;
try{
conn.setAutoCommit(false);
this.pstmt=conn.prepareStatement(sql);
pstmt.executeQuery();
}catch(Exceptione){
System.out.println("异常"+e.getMessage());
}
}
1.for update与 lock in share mode属于行级锁和页级锁
2.for update排它锁,lock in share mode共享锁
3.对于记录锁.必须开启事务.
4.行级锁定事实上是索引记录的锁定.只要是用索引扫描的行（或没索引全表扫描的行）,都将被锁住.
5.在不同的隔离级别下还会使用next-key locking算法.即所扫描的行之间的“间隙”也会也锁住(在Repeatable read和Serializable隔离级别下有间隙锁).
6.在mysql中共享锁的含义是:在被共享锁锁住的行,即使内容被修改且并没有提交.在另一个会话中依然看到最新修改的信息.
在同一会话中加上了共享锁.可以对这个表以及这个表以外的所有表进行增、删、改、查的操作.
在不同的会话中.可以查到共享锁锁住行的最新消息.但是在Read Uncommitted隔离级别下不能对锁住的表进行删，
改操作.（需要等待锁释放才能操作...）
在Read Committed隔离级别下不能对锁住的表进行删，改操作.（需要等待锁释放才能操作...）
在Repeatable read隔离级别下不能对锁住行进行增、删、改操作.（需要等待锁释放才能操作...）
在Serializable隔离级别下不能对锁住行进行增、删、改操作.（需要等待锁释放才能操作...）
7.在mysql中排他锁的含义是:在被排它锁锁住的行,内容修改并没提交，在另一个会话中不会看到最新修改的信息。
在不同的会话中.可以查到共享锁锁住行的最新消息.但是Read Uncommitted隔离级别下不能对锁住的表进行删，
改操作.（需要等待锁释放才能操作...）
在Read Committed隔离级别下不能对锁住的表进行删，改操作.（需要等待锁释放才能操作...）
在Repeatable read隔离级别下不能对锁住行进行增、删、改操作.（需要等待锁释放才能操作...）
在Serializable隔离级别下不能对锁住行进行增、删、改操作.（需要等待锁释放才能操作...）
8.在同一个会话中的可以叠加多个共享锁和排他锁.在多个会话中,需要等待锁的释放.
9.SQL中的update与 for update是一样的原理.
10.等待超时的参数设置:innodb_lock_wait_timeout=50(单位秒).
11.任何可以触发事务提交的命令,都可以关闭共享锁和排它锁.
java中几种Map在什么情况下使用,并简单介绍原因及原理
一、Map用于保存具有映射关系的数据，Map里保存着两组数据：key和value，它们都可以使任何引用类型的数据，但key不能重复。所以通过指定的key就可以取出对应的value。Map接口定义了如下常用的方法：
1、void clear():删除Map中所以键值对。
2、boolean containsKey(Object key):查询Map中是否包含指定key，如果包含则返回true。
3、boolean containsValue(Object value):查询Map中是否包含指定value，如果包含则返回true。
4、Set entrySet():返回Map中所包含的键值对所组成的Set集合，每个集合元素都是Map.Entry对象(Entry是Map的内部类)。
5、Object get(Object key):返回指定key所对应的value，如Map中不包含key则返回null。
6、boolean isEmpty():查询Map是否为空，如果空则返回true。
7、Set keySet():返回该Map中所有key所组成的set集合。
8、Object put(Object key,Object value):添加一个键值对，如果已有一个相同的key值则新的键值对覆盖旧的键值对。
9、void putAll(Map m):将指定Map中的键值对复制到Map中。
10、Object remove(Object key):删除指定key所对应的键值对，返回可以所关联的value，如果key不存在，返回null。
11、int size():返回该Map里的键值对的个数。
12、Collection values():返回该Map里所有value组成的Collection。
Map中包含一个内部类：Entry。该类封装了一个键值对，它包含了三个方法：
1、Object getKey():返回该Entry里包含的key值。
2、Object getValeu():返回该Entry里包含的value值。
3、Object setValue(V value):设置该Entry里包含的value值，并返回新设置的value值。
二、HashMap和Hashtable实现类：
1、HashMap与HashTable的区别：
1）同步性：Hashtable是同步的，这个类中的一些方法保证了Hashtable中的对象是线程安全的。而HashMap则是异步的，因此HashMap中的对象并不是线程安全的。因为同步的要求会影响执行的效率，所以如果你不需要线程安全的集合那么使用HashMap是一个很好的选择，这样可以避免由于同步带来的不必要的性能开销，从而提高效率。
2）值：HashMap可以让你将空值作为一个表的条目的key或value，但是Hashtable是不能放入空值的。HashMap最多只有一个key值为null，但可以有无数多个value值为null。
2、性能：HashMap的性能最好，HashTable的性能是最差（因为它是同步的）
3、注意：
1）用作key的对象必须实现hashCode和equals方法。
2）不能保证其中的键值对的顺序
3）尽量不要使用可变对象作为它们的key值。
三、LinkedHashMap：
它的父类是HashMap，使用双向链表来维护键值对的次序，迭代顺序与键值对的插入顺序保持一致。LinkedHashMap需要维护元素的插入顺序，so性能略低于HashMap，但在迭代访问元素时有很好的性能，因为它是以链表来维护内部顺序。
四、TreeMap:
Map接口派生了一个SortMap子接口，SortMap的实现类为TreeMap。TreeMap也是基于红黑树对所有的key进行排序，有两种排序方式：自然排序和定制排序。Treemap的key以TreeSet的形式存储，对key的要求与TreeSet对元素的要求基本一致。
1、Map.Entry firstEntry():返回最小key所对应的键值对，如Map为空，则返回null。
2、Object firstKey():返回最小key，如果为空，则返回null。
3、Map.Entry lastEntry():返回最大key所对应的键值对，如Map为空，则返回null。
4、Object lastKey():返回最大key，如果为空，则返回null。
5、Map.Entry higherEntry(Object key):返回位于key后一位的键值对，如果为空，则返回null。
6、Map.Entry lowerEntry(Object key):返回位于key前一位的键值对，如果为空，则返回null。
7、Object lowerKey(Object key):返回位于key前一位key值，如果为空，则返回null。
8、NavigableMap subMap(Object fromKey,boolean fromlnclusive,Object toKey,boolean toInciusive):返回该Map的子Map，其key范围从fromKey到toKey。
9、SortMap subMap(Object fromKey,Object toKey);返回该Map的子Map，其key范围从fromkey（包括）到tokey（不包括）。
10、SortMap tailMap（Object fromkey,boolean inclusive）:返回该Map的子Map，其key范围大于fromkey（是否包括取决于第二个参数）的所有key。
11、 SortMap headMap（Object tokey,boolean inclusive）:返回该Map的子Map，其key范围小于tokey（是否包括取决于第二个参数）的所有key。
五、WeakHashMap：
WeakHashMap与HashMap的用法基本相同，区别在于：后者的key保留对象的强引用，即只要HashMap对象不被销毁，其对象所有key所引用的对象不会被垃圾回收，HashMap也不会自动删除这些key所对应的键值对对象。但WeakHashMap的key所引用的对象没有被其他强引用变量所引用，则这些key所引用的对象可能被回收。WeakHashMap中的每个key对象保存了实际对象的弱引用，当回收了该key所对应的实际对象后，WeakHashMap会自动删除该key所对应的键值对。
六、IdentityHashMap类：
IdentityHashMap与HashMap基本相似，只是当两个key严格相等时，即key1==key2时，它才认为两个key是相等的。IdentityHashMap也允许使用null，但不保证键值对之间的顺序。
七、EnumMap类：
1、EnumMap中所有key都必须是单个枚举类的枚举值，创建EnumMap时必须显示或隐式指定它对应的枚举类。
2、EnumMap根据key的自然顺序，即枚举值在枚举类中定义的顺序，来维护键值对的次序。
3、EnumMap不允许使用null作为key值，但value可以。望采纳，谢谢。
文章分享结束，java什么情况下会锁表和java锁的可见性的是怎么保证的的答案你都知道了吗？欢迎再次光临本站哦！