关于java:Java中的锁原理锁优化

一、为什么要用锁？

锁 - 是为了解决并发操作引起的脏读、数据不统一的问题。

二、锁实现的基本原理

2.1、volatile

Java 编程语言容许线程访问共享变量，为了确保共享变量能被精确和统一地更新，线程应该确保通过排他锁独自取得这个变量。Java 语言提供了 volatile，在某些状况下比锁要更加不便。

volatile 在多处理器开发中保障了共享变量的“可见性”。可见性的意思是当一个线程批改一个共享变量时，另外一个线程能读到这个批改的值。

论断：如果 volatile 变量修饰符应用失当的话，它比 synchronized 的应用和执行老本更低，因为它不会引起线程上下文的切换和调度。

2.2、synchronized

synchronized 通过锁机制实现同步。

先来看下利用 synchronized 实现同步的根底：Java 中的每一个对象都能够作为锁。

具体表现为以下 3 种模式。

• 对于一般同步办法，锁是以后实例对象。
• 对于动态同步办法，锁是以后类的 Class 对象。
• 对于同步代码块，锁是 Synchonized 括号里配置的对象。

当一个线程试图拜访同步代码块时，它首先必须失去锁，退出或抛出异样时必须开释锁。

2.2.1 synchronized 实现原理

synchronized 是基于 Monitor 来实现同步的。

Monitor 从两个方面来反对线程之间的同步：

• 互斥执行
• 合作

1、Java 应用对象锁 (应用 synchronized 取得对象锁) 保障工作在共享的数据集上的线程互斥执行。

2、应用 notify/notifyAll/wait 办法来协同不同线程之间的工作。

3、Class 和 Object 都关联了一个 Monitor。

Monitor 的工作机理

• 线程进入同步办法中。
• 为了继续执行临界区代码，线程必须获取 Monitor 锁。如果获取锁胜利，将成为该监督者对象的拥有者。任一时刻内，监督者对象只属于一个流动线程（The Owner）
• 领有监督者对象的线程能够调用 wait() 进入期待汇合（Wait Set），同时开释监督锁，进入期待状态。
• 其余线程调用 notify() / notifyAll() 接口唤醒期待汇合中的线程，这些期待的线程须要从新获取监督锁后能力执行 wait() 之后的代码。
• 同步办法执行结束了，线程退出临界区，并开释监督锁。

2.2.2 synchronized 具体实现

1、同步代码块采纳 monitorenter、monitorexit 指令显式的实现。

2、同步办法则应用 ACC_SYNCHRONIZED 标记符隐式的实现。

通过实例来看看具体实现：

javap -c 编译后的字节码如下：

monitorenter

每一个对象都有一个 monitor，一个 monitor 只能被一个线程领有。当一个线程执行到 monitorenter 指令时会尝试获取相应对象的 monitor，获取规定如下：

• 如果 monitor 的进入数为 0，则该线程能够进入 monitor，并将 monitor 进入数设置为 1，该线程即为 monitor 的拥有者。
• 如果以后线程曾经领有该 monitor，只是从新进入，则进入 monitor 的进入数加 1，所以 synchronized 关键字实现的锁是可重入的锁。
• 如果 monitor 已被其余线程领有，则以后线程进入阻塞状态，直到 monitor 的进入数为 0，再从新尝试获取 monitor。

monitorexit

只有领有相应对象的 monitor 的线程能力执行 monitorexit 指令。每执行一次该指令 monitor 进入数减 1，当进入数为 0 时以后线程开释 monitor，此时其余阻塞的线程将能够尝试获取该 monitor。

monitorexit 有两个，另一个是用来确保异样完结时开释 monitor 指令.

2.2.3 锁寄存的地位

锁标记寄存在 Java 对象头的 Mark Word 中。

Java 对象头长度

32 位 JVM Mark Word 构造

32 位 JVM Mark Word 状态变动

64 位 JVM Mark Word 构造

2.2.4 synchronized 的锁优化

在 JavaSE1.6 中，锁一共有 4 种状态，级别从低到高顺次是：无锁状态、偏差锁状态、轻量级锁状态和重量级锁状态，这几个状态会随着竞争状况逐步降级。

锁能够降级但不能降级，意味着偏差锁升级成轻量级锁后不能降级成偏差锁。这种锁降级却不能降级的策略，目标是为了进步取得锁和开释锁的效率。

适应性自旋（Adaptive Spinning）：自适应意味着自旋的工夫不再固定了，而是由前一次在同一个锁上的自旋工夫及锁的拥有者的状态来决定。如果在同一个锁对象上，自旋期待刚刚胜利取得过锁，并且持有锁的线程正在运行中，那么虚拟机就会认为这次自旋也很有可能再次胜利，进而它将容许自旋期待继续绝对更长的工夫，比方 100 个循环。另一方面，如果对于某个锁，自旋很少胜利取得过，那在当前要获取这个锁时将可能省略掉自旋过程，以避免浪费处理器资源。

有了自适应自旋锁，随着程序运行和性能监控信息的不断完善，虚拟机对程序锁的情况预测会越来越精确，虚构机会变得越来越聪慧。

锁粗化（Lock Coarsening）：也就是缩小不必要的紧连在一起的 unlock，lock 操作，将多个间断的锁扩大成一个范畴更大的锁。

锁打消（Lock Elimination）：锁削除是指虚拟机即时编译器在运行时，对一些代码上要求同步，然而被检测到不可能存在共享数据竞争的锁进行削除。锁打消的次要断定根据来源于逃逸剖析技术。

偏差锁：

引入偏差锁的次要目标是：为了在 无多线程竞争 的状况下尽量减少不必须要的轻量级锁执行门路。其实在大多数状况下，锁不仅不存在多线程竞争，而且总是由同一个线程屡次获取，所以引入偏差锁就能够缩小很多不必要的性能开销和上下文切换。

轻量级锁：

引入轻量级锁的次要目标是：在多线程 竞争不强烈 的前提下，缩小传统的重量级锁应用操作系统互斥量产生的性能耗费。

轻量级锁所适应的场景是线程交替执行同步块的状况。

所以偏差锁是认为环境中不存在竞争状况，而轻量级锁则是认为环境中不存在竞争或者竞争不强烈，轻量级锁所以个别都只会有少数几个线程竞争锁对象，其余线程只须要略微期待（自旋）下就能够获取锁，然而自旋次数有限度，如果超过该次数，则会降级为重量级锁。

重量级锁

监视器锁 Monitor

常识补充：java 对象头

对象在内存中存储的布局能够分为三块区域：对象头 （Header）、 实例数据（Instance Data）和对齐填充（Padding）。

一般对象的对象头包含两局部：Mark Word 和 Class Metadata Address（类型指针），如果是数组对象还包含一个额定的 Array length 数组长度局部。

Mark Word：用于存储对象本身的运行时数据，如哈希码（HashCode）、GC 分代年龄、锁状态标记、线程持有的锁、偏差线程 ID、偏差工夫戳等等，占用内存大小与虚拟机位长统一。

Class Metadata Address：类型指针指向对象的类元数据，虚拟机通过这个指针确定该对象是哪个类的实例。

synchronized 用的锁是存储在 Java 对象头里的，下图是锁状态变动的状况，在剖析 synchronized 锁降级须要对照这图：

1）一个锁对象刚刚开始创立的时候，没有任何线程来拜访它，此时线程状态为无锁状态。Mark word（锁标记位 -01 是否偏差 -0）

2）当线程 A 来拜访这个对象锁时，它会偏差这个线程 A。线程 A 查看 Mark word（锁标记位 -01 是否偏差 -0）为无锁状态。此时，有线程拜访锁了，无锁降级为偏差锁，Mark word（锁标记位 -01，是否偏差 -1，线程 ID- 线程 A 的 ID）

3）当线程 A 执行完同步块时，不会被动开释偏差锁。持有偏差锁的线程执行完同步代码后不会被动开释偏差锁，而是期待其余线程来竞争才会开释锁。Mark word 不变（锁标记位 -01，是否偏差 -1，线程 ID- 线程 A 的 ID）

4）当线程 A 再次获取这个对象锁时，查看 Mark word（锁标记位 -01，是否偏差 -1，线程 ID- 线程 A 的 ID），偏差锁且偏差线程 A，能够间接执行同步代码。这样 偏差锁保障了总是同一个线程屡次获取锁的状况下，每次只须要查看标记位就行，效率很高。

5）当线程 A 执行完同步块之后，线程 B 获取这个对象锁 查看 Mark word（锁标记位 -01，是否偏差 -1，线程 ID- 线程 A 的 ID），偏差锁且偏差线程 A。有不同的线程获取锁对象，偏差锁降级为轻量级锁，并由线程 B 获取该锁。

6）当线程 A 正在执行同步块时，也就是正持有偏差锁时，线程 B 获取来这个对象锁。

查看 Mark word（锁标记位 -01，是否偏差 -1，线程 ID- 线程 A 的 ID），偏差锁且偏差线程 A。

线程 A 撤销偏差锁:

1. 等到全局平安点执行撤销偏差锁，暂停持有偏差锁的线程 A 并查看程 A 的状态；
2. 如果线程 A 不处于活动状态或者曾经退出同步代码块，则将对象锁设置为无锁状态，而后再降级为轻量级锁。由线程 B 获取轻量级锁。
3. 如果线程 A 还在执行同步代码块，也就是线程 A 还须要这个对象锁，则偏差锁收缩为轻量级锁。

线程 A 收缩为轻量级锁过程：

1. 在降级为轻量级锁之前，持有偏差锁的线程（线程 A）是暂停的
2. 线程 A 栈帧中创立一个名为锁记录的空间（Lock Record）
3. 锁对象头中的 Mark Word 拷贝到线程 A 的锁记录中
4. Mark Word 的锁标记位变为 00，指向锁记录的指针指向线程 A 的锁记录地址，Mark word（锁标记位 -00，其余位 - 线程 A 锁记录的指针）
5. 当原持有偏差锁的线程（线程 A）获取轻量级锁后，JVM 唤醒线程 A，线程 A 执行同步代码块

7）线程 A 持有轻量级锁，线程 A 执行完同步块代码之后，始终没有线程来竞争对象锁，失常开释轻量级锁。开释轻量级锁操作：CAS 操作将线程 A 的锁记录（Lock Record）中的 Mark Word 替换回锁对象头中。

8）线程 A 持有轻量级锁，执行同步块代码过程中，线程 B 来竞争对象锁。

Mark word（锁标记位 -00，其余位 - 线程 A 锁记录的指针）

1. 线程 B 会先在栈帧中建设锁记录，存储锁对象目前的 Mark Word 的拷贝
2. 线程 B 通过 CAS 操作尝试将锁对象的 Mark Word 的指针指向线程 B 的 Lock Record，如果胜利，阐明线程 A 刚刚开释锁，线程 B 竞争到锁，则执行同步代码块。
3. 因为线程 A 始终持有锁，大部分状况下 CAS 是会失败的。CAS 失败之后，线程 B 尝试应用自旋的形式来期待持有轻量级锁的线程开释锁。
4. 线程 B 不会始终自旋上来，如果自旋了肯定次数后还是失败，线程 B 会被阻塞，期待开释锁后唤醒。此时轻量级锁就会收缩为重量级锁。Mark word（锁标记位 -10，其余位 - 重量级锁 monitor 的指针）
5. 线程 A 执行完同步块代码之后，执行开释锁操作，CAS 操作将线程 A 的锁记录（Lock Record）中的 Mark Word 替换回锁对象对象头中，因为对象头中曾经不是原来的轻量级锁的指针了，而是重量级锁的指针，所以 CAS 操作会失败。
6. 开释轻量级锁 CAS 操作替换失败之后，须要在开释锁的同时须要唤醒被挂起的线程 B。线程 B 被唤醒，获取重量级锁 monitor

三 锁分类

偏心锁 / 非偏心锁

偏心锁是指多个线程依照申请锁的程序来获取锁。

非偏心锁是指多个线程获取锁的程序并不是依照申请锁的程序，有可能后申请的线程比先申请的线程优先获取锁。有可能，会造成优先级反转或者饥饿景象。

对于 Java ReentrantLock 而言，通过构造函数指定该锁是否是偏心锁，默认是非偏心锁。非偏心锁的长处在于吞吐量比偏心锁大。

对于 Synchronized 而言，也是一种非偏心锁。因为其并不像 ReentrantLock 是通过 AQS 的来实现线程调度，所以并没有任何方法使其变成偏心锁。

可重入锁

可重入锁又名递归锁，是指在同一个线程在外层办法获取锁的时候，在进入内层办法会主动获取锁。说的有点形象，上面会有一个代码的示例。

对于 Java ReentrantLock 而言, 他的名字就能够看出是一个可重入锁，其名字是 Re entrant Lock 从新进入锁。

对于 Synchronized 而言, 也是一个可重入锁。可重入锁的一个益处是可肯定水平防止死锁。

synchronized void setA() throws Exception{Thread.sleep(1000);
    setB();}

synchronized void setB() throws Exception{Thread.sleep(1000);
}

下面的代码就是一个可重入锁的一个特点，如果不是可重入锁的话，setB 可能不会被以后线程执行，可能造成死锁。

独享锁 / 共享锁

独享锁是指该锁一次只能被一个线程所持有。

共享锁是指该锁可被多个线程所持有。

对于 Java ReentrantLock 而言，其是独享锁。然而对于 Lock 的另一个实现类 ReadWriteLock，其读锁是共享锁，其写锁是独享锁。

读锁的共享锁可保障并发读是十分高效的，读写，写读，写写的过程是互斥的。

独享锁与共享锁也是通过 AQS 来实现的，通过实现不同的办法，来实现独享或者共享。

对于 Synchronized 而言，当然是独享锁。

互斥锁 / 读写锁

下面讲的独享锁 / 共享锁就是一种狭义的说法，互斥锁 / 读写锁就是具体的实现。

互斥锁在 Java 中的具体实现就是 ReentrantLock

读写锁在 Java 中的具体实现就是 ReadWriteLock

乐观锁 / 乐观锁

乐观锁与乐观锁不是指具体的什么类型的锁，而是指对待并发同步的角度。

乐观锁认为对于同一个数据的并发操作，肯定是会产生批改的，哪怕没有批改，也会认为批改。因而对于同一个数据的并发操作，乐观锁采取加锁的模式。乐观的认为，不加锁的并发操作肯定会出问题。

乐观锁则认为对于同一个数据的并发操作，是不会产生批改的。在更新数据的时候，会采纳尝试更新，一直从新的形式更新数据。乐观的认为，不加锁的并发操作是没有事件的。

从下面的形容咱们能够看出，乐观锁适宜写操作十分多的场景，乐观锁适宜读操作十分多的场景，不加锁会带来大量的性能晋升。

乐观锁在 Java 中的应用，就是利用各种锁。

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

分段锁

分段锁其实是一种锁的设计，并不是具体的一种锁，对于 ConcurrentHashMap 而言，其并发的实现就是通过分段锁的模式来实现高效的并发操作。

咱们以 ConcurrentHashMap 来说一下分段锁的含意以及设计思维，ConcurrentHashMap 中的分段锁称为 Segment，它即相似于 HashMap（JDK7 与 JDK8 中 HashMap 的实现）的构造，即外部领有一个 Entry 数组，数组中的每个元素又是一个链表；同时又是一个 ReentrantLock（Segment 继承了 ReentrantLock)。

当须要 put 元素的时候，并不是对整个 hashmap 进行加锁，而是先通过 hashcode 来晓得他要放在那一个分段中，而后对这个分段进行加锁，所以当多线程 put 的时候，只有不是放在一个分段中，就实现了真正的并行的插入。

然而，在统计 size 的时候，可就是获取 hashmap 全局信息的时候，就须要获取所有的分段锁能力统计。

分段锁的设计目标是细化锁的粒度，当操作不须要更新整个数组的时候，就仅仅针对数组中的一项进行加锁操作。

偏差锁 / 轻量级锁 / 重量级锁

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

偏差锁是指一段同步代码始终被一个线程所拜访，那么该线程会主动获取锁。升高获取锁的代价。

轻量级锁是指当锁是偏差锁的时候，被另一个线程所拜访，偏差锁就会降级为轻量级锁，其余线程会通过自旋的模式尝试获取锁，不会阻塞，进步性能。

重量级锁是指当锁为轻量级锁的时候，另一个线程尽管是自旋，但自旋不会始终继续上来，当自旋肯定次数的时候，还没有获取到锁，就会进入阻塞，该锁收缩为重量级锁。重量级锁会让其余申请的线程进入阻塞，性能升高。

自旋锁

在 Java 中，自旋锁是指尝试获取锁的线程不会立刻阻塞，而是采纳循环的形式去尝试获取锁，这样的益处是缩小线程上下文切换的耗费，毛病是循环会耗费 CPU。JDK 自旋的默认次数为 10 次，能够通过参数 -XX:PreBlockSpin 来调整。