Java多线程并发05——那么多的锁你都了解了吗

在多线程或高并发情境中，常常会为了保证数据一致性，而引入锁机制，本文将为各位带来有关锁的基本概念讲解。关注个人公众号「Java面典」了解更多 Java 相关知识点。

根据锁的各类特性，可将锁分为如下几类：

• 乐观锁/悲观锁
• 独享锁（互斥锁）/共享锁（读写锁）
• 可重入锁
• 公平锁/非公平锁
• 分段锁
• 偏向锁/轻量级锁/重量级锁
• 自旋锁

乐观锁/悲观锁

乐观锁与悲观锁并非特指某两种类型的锁，是人们定义出来的概念或思想，主要是指看待并发同步的角度。

乐观锁

前提：认为读多写少，遇到并发写的可能性低，每次去拿数据的时候都认为别人不会修改，因此不会上锁；

实现：在更新的时候会判断一下在此期间别人有没有去更新这个数据，采起在写时先读出当前版本号，而后加锁操做（比较跟上一次的版本号，若是同样则更新），若是失败则要重复读-比较-写的操做。

应用：在 Java 中 java.util.concurrent.atomic 包下面的原子变量类就是使用了乐观锁的一种实现方式CAS(Compare and Swap 【比较并交换】)实现的。CAS 是一种更新的原子操做，比较当前值跟传入值是否同样，同样则更新，不然失败。

悲观锁

前提：认为写多，遇到并发写的可能性高，每次去拿数据的时候都认为别人会修改；

实现： 老是假设最坏的状况，以每次在读写数据的时候都会上锁，这样别人想读写这个数据就会阻塞直到拿到锁；

应用：Java中的 Synchronized 就是悲观锁，AQS 框架下的锁则是先尝试 CAS 乐观锁去获取锁，获取不到，才会转换为悲观锁，如 RetreenLock。

小结

• 悲观锁适合写操做很是多的场景，乐观锁适合读操做很是多的场景，不加锁会带来大量的性能提高；

• 悲观锁在 Java 中的使用，就是利用各类锁；

• 乐观锁在 Java 中的使用，是无锁编程，经常采用的是 CAS 算法，典型的例子就是原子类，经过 CAS 自旋实现原子操做的更新。

独享锁（互斥锁）/共享锁（读写锁）

独享锁（互斥锁）

定义： 独享锁是指该锁一次只能被一个线程所持有；

特色：独占锁是一种悲观保守的加锁策略，它避免了读/读冲突，若是某个只读线程获取锁，则其余读线程都只能等待，这种状况下就限制了没必要要的并发性，由于读操做并不会影响数据的一致性。

应用：ReentrantLock 就是以独占方式实现的互斥锁。

共享锁（读写锁）

定义：共享锁是指该锁可同时被多个线程所持有，并发访问、共享资源；

特色：共享锁则是一种乐观锁，它放宽了加锁策略，容许多个执行读操做的线程同时访问共享资源；

应用：

1. AQS 的内部类 Node 定义了两个常量 SHARED 和 EXCLUSIVE，他们分别标识 AQS 队列中等待线程的锁获取模式。
2. java 的并发包中提供了 ReadWriteLock，读-写锁。它容许一个资源能够被多个读操做访问，或者被一个 写操做访问，但二者不能同时进行。

可重入锁（递归锁）

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

应用：在 JAVA 环境下 ReentrantLock 和 synchronized 都是可重入锁。

公平锁/非公平锁

公平锁

加锁前检查是否有排队等待的线程，优先排队等待的线程，先来先得。

非公平锁

加锁时不考虑排队等待问题，直接尝试获取锁，获取不到自动到队尾等待。

1. 非公平锁性能比公平锁高 5~10 倍，由于公平锁须要在多核的状况下维护一个队列；
2. Java 中的 synchronized 是非公平锁，ReentrantLock 默认的 lock()方法采用的是非公平锁。

分段锁

分段锁也并不是一种实际的锁，而是一种思想 ConcurrentHashMap 是学习分段锁的最好实践。

偏向锁/轻量级锁/重量级锁

这三种锁是指锁的状态，而且是针对Synchronized。在Java 5经过引入锁升级的机制来实现高效Synchronized。这三种锁的状态是经过对象监视器在对象头中的字段来代表的。

偏向锁

指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。下降获取锁的代价。

轻量级锁

指当锁是偏向锁的时候，被另外一个线程所访问，偏向锁就会升级为轻量级锁，其余线程会经过自旋的形式尝试获取锁，不会阻塞，提升性能。

重量级锁

指当锁为轻量级锁的时候，另外一个线程虽然是自旋，但自旋不会一直持续下去，当自旋必定次数的时候，尚未获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让他申请的线程进入阻塞，性能下降。

自旋锁

在Java中，自旋锁是指尝试获取锁的线程不会当即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减小线程上下文切换的消耗，缺点是循环会消耗CPU。

特色

1. 自旋锁尽量的减小线程的阻塞；
2. 减小线程上下文切换的消耗，这对于锁的竞争不激烈，且占用锁时间很是短的代码块来讲性能能大幅度的提高；
3. 若是锁的竞争激烈，或者占用锁时间长短的代码块，不适合使用自旋锁。同时有大量线程在竞争一个锁，会致使获取锁的时间很长，线程自旋的消耗大于线程阻塞挂起操做的消耗，其它须要 CPU 的线程又不能获取到 CPU，形成 CPU 的浪费。因此这种状况下咱们要关闭自旋锁。

适应性自旋锁

在 JDK1.5 及以前自旋时间是固定的，从 JDK1.6 开始，引入了适应性自旋锁。

• 特色：

1. 自旋时间由前一次在同一个锁上的自旋时间以及锁的拥有者的状态来决定；
2. 基本认为一个线程上下文切换的时间是最佳的一个时间。

• 优化：
  JVM 还针对当前 CPU 的负荷状况作了较多的优化：

1. 若是平均负载小于 CPUs 则一直自旋，若是有超过(CPUs/2)个线程正在自旋，则后来线程直接阻塞；
2. 若是正在自旋的线程发现 Owner 发生了变化则延迟自旋时间（自旋计数）或进入阻塞；
3. 若是 CPU 处于节电模式则中止自旋；
4. 自旋时间的最坏状况是 CPU的存储延迟（CPU A 存储了一个数据，到 CPU B 得知这个数据直接的时间差），自旋时会适当放弃线程优先级之间的差别。

锁的优化

在Java中，须要谨慎使用锁。如无必要，不用最好；必需要用的话，也须要尽量优化锁的使用，以此来提升程序的吞吐量。关于锁的优化，主要分为应用方面的优化与 JVM 方面的优化，JVM方面的优化，通常不须要开发人员操心，开发人员更应该提高自身代码素质，关注应用方面的优化。

应用优化

• 减小锁持有时间：只用在有线程安全要求的程序上加锁；
• 减少锁粒度：将大对象（这个对象可能会被不少线程访问），拆成小对象，大大增长并行度，下降锁竞争。下降了锁的竞争，偏向锁，轻量级锁成功率才会提升。最最典型的减少锁粒度的案例就是ConcurrentHashMap；
• 锁分离：最多见的锁分离就是读写锁 ReadWriteLock，根据功能进行分离成读锁和写锁，这样读读不互斥，读写互斥，写写互斥，即保证了线程安全，又提升了性能。读写分离思想能够延伸，只要操做互不影响，锁就能够分离。好比LinkedBlockingQueue 从头部取出，从尾部放数据。

JVM优化

• 锁粗化：一般状况下，为了保证多线程间的有效并发，会要求每一个线程持有锁的时间尽可能短，即在使用完公共资源后，应该当即释放锁。可是，凡事都有一个度，若是对同一个锁不停的进行请求、同步和释放，其自己也会消耗系统宝贵的资源，反而不利于性能的优化 ；
• 锁消除：锁消除是在编译器级别的事情。在即时编译器时，若是发现不可能被共享的对象，则能够消除这些对象的锁操做，多数是由于程序员编码不规范引发。

---

多线程与并发系列推荐

Java多线程并发04——合理使用线程池

Java多线程并发03——什么是线程上下文，线程是如何调度的

Java多线程并发02——线程的生命周期与经常使用方法，你都掌握了吗

Java多线程并发01——线程的建立与终止，你会几种方式