随笔20 java中锁的种类及分析

http://www.importnew.com/19472.html

一：java中的锁

java中各种锁的概念包括：公平锁、非公平锁、自旋锁、可重入锁、偏向锁、轻量级锁、重量级锁、读写锁、互斥锁等待。

  • 公平锁和非公平锁
    • 公平锁是指多个线程在等待同一个锁时，必须按照申请锁的先后顺序来一次获得锁。
    • 公平锁的好处是等待锁的线程不会饿死，但是整体效率相对低一些；
    • 非公平锁的好处是整体效率相对高一些，但是有些线程可能会饿死或者说很早就在等待锁，但要等很久才会获得锁。
    • 其中的原因是公平锁是严格按照请求所的顺序来排队获得锁的，而非公平锁时可以抢占的，即如果在某个时刻有线程需要获取锁，而这个时候刚好锁可用，那么这个线程会直接抢占，而这时阻塞在等待队列的线程则不会被唤醒。
    • 公平锁可以使用new ReentrantLock(true)实现。
  • 自旋锁
    • Java的线程是映射到操作系统的原生线程之上的，如果要阻塞或唤醒一个线程，都需要操作系统来帮忙完成，这就需要从用户态转换到核心态中，因此状态装换需要耗费很多的处理器时间，对于代码简单的同步块（如被synchronized修饰的getter()和setter()方法），状态转换消耗的时间有可能比用户代码执行的时间还要长。
    • 虚拟机的开发团队注意到在许多应用上，共享数据的锁定状态只会持续很短的一段时间，为了这段时间取挂起和恢复现场并不值得。如果物理机器有一个以上的处理器，能让两个或以上的线程同时并行执行，我们就可以让后面请求锁的那个线程“稍等一下“，但不放弃处理器的执行时间，看看持有锁的线程是否很快就会释放锁。为了让线程等待，我们只需让线程执行一个忙循环（自旋），这项技术就是所谓的自旋锁。
    • 自旋等待不能代替阻塞。自旋等待本身虽然避免了线程切换的开销，但它是要占用处理器时间的，因此，如果锁被占用的时间很短，自旋等待的效果就会非常好，反之，如果锁被占用的时间很长，那么自旋的线程只会白白浪费处理器资源。因此，自旋等待的时间必须要有一定的限度，如果自旋超过了限定次数（默认是10次，可以使用-XX:PreBlockSpin来更改）没有成功获得锁，就应当使用传统的方式去挂起线程了。
    • 自旋锁在JDK1.4.2中引入，使用-XX:+UseSpinning来开启。JDK6中已经变为默认开启，并且引入了自适应的自旋锁。自适应意味着自旋的时间不在固定了，而是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定。
    • 自旋是在轻量级锁中使用的，在重量级锁中，线程不使用自旋。
    • 如果在同一个锁对象上，自旋等待刚刚成功获得过锁，并且持有锁的线程正在运行中，那么虚拟机就会认为这次自旋也是很有可能再次成功，进而它将允许自旋等待持续相对更长的时间，比如100次循环。另外，如果对于某个锁，自旋很少成功获得过，那在以后要获取这个锁时将可能省略掉自旋过程，以避免浪费处理器资源。

  • 锁消除

    • 锁消除是虚拟机JIT（JIT 是 just in time 的缩写, 也就是即时编译器。）在运行时，对一些代码上要求同步，但是被检测到不可能存在共享数据竞争的锁进行消除。锁消除的主要判断依据是来源于逃逸分析的数据支持，如果判断在一段代码中，堆上的所有数据都不会逃逸出去从而能被其他线程访问到，那就可以把他们当做栈上数据对待，认为他们是线程私有的，同步加锁自然就无需进行。　

    • 来看这样一个方法：

    • 1 public String concatString(String s1, String s2, String s3){
2        StringBuffer sb = new StringBuffer();
3        sb.append(s1);
4        sb.append(s2);
5        sb.append(s3);
6        return sb.toString();
7 }
    • 可以知道StringBuffer 的append方法定义如下：
    • 1 public synchronized StringBuffer append(StringBuffer sb) {
2         super.append(sb);
3         return this;
4 }

      也就是说在concatString()方法中涉及了同步操作。但是可以观察到sb对象它的作用域被限制在方法的内部，也就是sb对象不会“逃逸”出去，其他线程无法访问。因此，虽然这里有锁，但是可以被安全的消除，在即时编译之后，这段代码就会忽略掉所有的同步而直接执行了。

  • 锁粗化

    • 原则上，我们在编写代码的时候，总是推荐将同步块的作用范围限制的尽量小——只在共享数据的实际作用域中才进行同步，这样是为了使得需要同步的操作数量尽可能变小，如果存在锁禁止，那等待的线程也能尽快拿到锁。大部分情况下，这些都是正确的。但是，如果一些列的联系操作都是同一个对象反复加上和解锁，甚至加锁操作是出现在循环体中的，那么即使没有线程竞争，频繁地进行互斥同步操作也导致不必要的性能损耗。

    • 举个案例，类似锁消除的concatString()方法。如果StringBuffer sb = new StringBuffer();定义在方法体之外，那么就会有线程竞争，但是每个append()操作都对同一个对象反复加锁解锁，那么虚拟机探测到有这样的情况的话，会把加锁同步的范围扩展到整个操作序列的外部，即扩展到第一个append()操作之前和最后一个append()操作之后，这样的一个锁范围扩展的操作就称之为锁粗化。

  • 可重入锁

    • 可重入锁，也叫做递归锁，指的是同一线程外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码，但不受影响。

    • 在JAVA环境下 ReentrantLock 和synchronized 都是可重入锁。可重入锁最大的作用是避免死锁。

  •  类锁和对象锁

    • 类锁：在方法上加上static synchronized的锁，或者synchronized(xxx.class)的锁。如下代码中的method1和method2：

    • 对象锁：参考method4, method5,method6.

 1 public class LockStrategy{
 2     public Object object1 = new Object();
 3     public static synchronized void method1(){}
 4     public void method2(){
 5         synchronized(LockStrategy.class){}
 6     }
 7     public synchronized void method4(){}
 8     public void method5(){
 9         synchronized(this){}
10     }
11     public void method6(){
12         synchronized(object1){}
13     }
14 }

  • 偏向锁、轻量级锁和重量级锁

    • synchronized的偏向锁、轻量级锁以及重量级锁是通过Java对象头实现的。Java对象的内存布局分为：对象头、实例数据和对其填充，而对象头又可以分为”Mark Word”和类型指针klass。”Mark Word”是关键，默认情况下，其存储对象的HashCode、分代年龄和锁标记位。
    • 这里说的都是以HotSpot虚拟机为基准的。首先来看一下”Mark Word”的内容：

    • 注意到这里的无锁和偏向锁在”Mark Word”的倒数第三bit中分别采用0和1标记。

    • 偏向锁是JDK6中引入的一项锁优化，它的目的是消除数据在无竞争情况下的同步原语，进一步提高程序的运行性能。
    • 偏向锁会偏向于第一个获得它的线程，如果在接下来的执行过程中，该锁没有被其他的线程获取，则持有偏向锁的线程将永远不需要同步。大多数情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得，为了让线程获得锁的代价更低而引入了偏向锁。
    • 当锁对象第一次被线程获取的时候，线程使用CAS(Compare and Swap)操作把这个锁的线程ID记录在对象Mark Word之中，同时置偏向标志位1。以后该线程在进入和退出同步块时不需要进行CAS操作来加锁和解锁，只需要简单地测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁。如果测试成功，表示线程已经获得了锁。
    • 如果线程使用CAS操作时失败则表示该锁对象上存在竞争并且这个时候另外一个线程获得偏向锁的所有权。当到达全局安全点（safepoint，这个时间点上没有正在执行的字节码）时获得偏向锁的线程被挂起，膨胀为轻量级锁（涉及Monitor Record，Lock Record相关操作，这里不展开），同时被撤销偏向锁的线程继续往下执行同步代码。
    • 当有另外一个线程去尝试获取这个锁时，偏向模式就宣告结束。
    • 线程在执行同步块之前，JVM会先在当前线程的栈帧中创建用于存储锁记录(Lock Record)的空间，并将对象头中的Mark Word复制到锁记录中，官方称为Displaced Mark Word。然后线程尝试使用CAS将对象头中的Mark Word替换为指向锁记录的指针。如果成功，当前线程获得锁，如果失败，表示其他线程竞争锁，当前线程便尝试使用自旋来获取锁。如果自旋失败则锁会膨胀成重量级锁。如果自旋成功则依然处于轻量级锁的状态。
    • 轻量级锁的解锁过程也是通过CAS操作来进行的，如果对象的Mark Word仍然指向线程的锁记录，那就用CAS操作把对象当前的Mark Word和线程中赋值的Displaced Mark Word替换回来，如果替换成功，整个同步过程就完成了，如果替换失败，就说明有其他线程尝试过获取该锁，那就要在释放锁的同时，唤醒被挂起的线程。
    • 轻量级锁提升程序同步性能的依据是：对于绝大部分的锁，在整个同步周期内都是不存在竞争的（区别于偏向锁）。这是一个经验数据。如果没有竞争，轻量级锁使用CAS操作避免了使用互斥量的开销，但如果存在锁竞争，除了互斥量的开销外，还额外发生了CAS操作，因此在有竞争的情况下，轻量级锁比传统的重量级锁更慢。
    • 整个synchronized锁流程如下：
      • 检测Mark Word里面是不是当前线程的ID，如果是，表示当前线程处于偏向锁；
      • 如果不是，则使用CAS将当前线程的ID替换Mard Word，如果成功则表示当前线程获得偏向锁，置偏向标志位1；
      • 如果失败，则说明发生竞争，撤销偏向锁，进而升级为轻量级锁。
      • 当前线程使用CAS将对象头的Mark Word替换为锁记录指针，如果成功，当前线程获得锁；
      • 如果失败，表示其他线程竞争锁，当前线程便尝试使用自旋来获取锁。
      • 如果自旋成功则依然处于轻量级状态。
      • 如果自旋失败，则升级为重量级锁。

  • 悲观锁和乐观锁

    • 悲观锁：假定会发生并发冲突，屏蔽一切可能违反数据完整性的操作。
    • 乐观锁：假定不会发生并发冲突，只在提交操作时检测是否违反数据完整性。（使用版本号或者时间戳来配合实现）。

  • 共享锁和排它锁

    • 共享锁：如果事务T对数据A加上共享锁后，则其他事务只能对A再加共享锁，不能加排它锁。获得共享锁的事务只能读数据，不能修改数据。
    • 排它锁：如果事务T对数据A加上排它锁后，则其他事务不能再对A加任何类型的锁。获得排它锁的事务即能读数据又能修改数据。

  • 读写锁

    • 读写锁是一个资源能够被多个读线程访问，或者被一个写线程访问但不能同时存在读线程。Java当中的读写锁通过ReentrantReadWriteLock实现。具体使用方法这里不展开。　　

  • 互斥锁

    • 所谓互斥锁就是指一次最多只能有一个线程持有的锁。在JDK中synchronized和JUC的Lock就是互斥锁。　

  • 无锁

    • 要保证现场安全，并不是一定就要进行同步，两者没有因果关系。同步只是保证共享数据争用时的正确性的手段，如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性，因此会有一些代码天生就是线程安全的。　
      • 无状态编程。无状态代码有一些共同的特征：不依赖于存储在对上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非无状态的方法等。可以参考Servlet。
      • 线程本地存储。可以参考ThreadLocal
      • volatile
      • CAS
      • 协程：在单线程里实现多任务的调度，并在单线程里维持多个任务间的切换。

二：java中的并发

一个线程执行的过程有三个阶段：

 

加载（复制）主存数据到操作栈 -->  对操作栈数据进行修改  --> 将操作栈数据写回主存。

 

volatite关键字，让编译器不去优化代码使用缓存等，以保证线程在“加载数据阶段”加载的数据都是最新的。
1、CopyOnWriteArrayList的实现原理

在使用CopyOnWriteArrayList之前，我们先阅读其源码了解下它是如何实现的。以下代码是向ArrayList里添加元素，可以发现在添加的时候是需要加锁的，否则多线程写的时候会Copy出N个副本出来。

 

 1 public boolean add(T e) {
 2     final ReentrantLock lock = this.lock;
 3     lock.lock();
 4     try {
 5         Object[] elements = getArray();
 6         int len = elements.length;
 7         // 复制出新数组
 8         Object[] newElements = Arrays.copyOf(elements, len + 1);
 9         // 把新元素添加到新数组里
10         newElements[len] = e;
11         // 把原数组引用指向新数组
12         setArray(newElements);
13         return true;
14     } finally {
15         lock.unlock();
16     }
17 }
18 final void setArray(Object[] a) {
19     array = a;
20 }

 

读的时候不需要加锁，如果读的时候有多个线程正在向ArrayList添加数据，读还是会读到旧的数据，因为写的时候不会锁住旧的ArrayList。

1 public E get(int index) {
2     return get(getArray(), index);
3 } CopyOnWriteArrayList适用于读多写少的并发场景

2、ReadWriteLock写与写之间互斥，读与写之间互斥，读与读之间并发，所以适用于读多写少。

3、ConcurrentHashMap是同步的HashMap，读写都加锁。

 

posted @ 2017-11-13 13:17  叶枫啦啦  阅读(310)  评论(0)  编辑  收藏  举报