java 对象锁实现方式_java并发系列(3)——深入synchronized对象锁

1、synchronized的基本使用

Synchronized的作用主要有三个：(1)确保线程互斥的访问同步代码(2)保证共享变量的修改能够及时可见(3)有效解决重排序问题。

从语法上讲，Synchronized总共有三种用法：

(1)修饰普通方法

(2)修饰静态方法(对class的对象锁)

(3)修饰代码块

public class SynchronizedTest {

public synchronized void method1(){

System.out.println("Method 1 start");

try {

System.out.println("Method 1 execute");

Thread.sleep(3000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("Method 1 end");

}

public static synchronized void method2(){

System.out.println("Method 2 start");

try {

System.out.println("Method 2 execute");

Thread.sleep(3000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("Method 1 end");

}

public void method3(){

System.out.println("Method 3 start");

try {

synchronized (this) {

System.out.println("Method 3 execute");

Thread.sleep(1000);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("Method 3 end");

}

public static void main(String[] args) {

final SynchronizedTest test = new SynchronizedTest();

new Thread(new Runnable() {

@Override

public void run() {

test.method1();

}

}).start();

new Thread(new Runnable() {

@Override

public void run() {

SynchronizedTest.method2();

}

}).start();

new Thread(new Runnable() {

@Override

public void run() {

test.method3();

}

}).start();

}

}

2、深入synchronized

Paste_Image.png

Synchronized是通过对象内部的一个叫做监视器锁(monitor)来实现的。但是监视器锁本质又是依赖于底层的操作系统的Mutex Lock来实现的。而操作系统实现线程之间的切换这就需要从用户态转换到核心态，这个成本非常高，状态之间的转换需要相对比较长的时间，这就是为什么Synchronized效率低的原因。因此，这种依赖于操作系统Mutex Lock所实现的锁我们称之为“重量级锁”。JDK中对Synchronized做的种种优化，其核心都是为了减少这种重量级锁的使用。JDK1.6以后，为了减少获得锁和释放锁所带来的性能消耗，提高性能，引入了“偏向锁”和“轻量级锁”。

java对象头与对象锁

Paste_Image.png

偏向锁

偏向锁，顾名思义，它会偏向于第一个访问锁的线程，如果在接下来的运行过程中，该锁没有被其他的线程访问，则持有偏向锁的线程将永远不需要触发同步。 如果在运行过程中，遇到了其他线程抢占锁，则持有偏向锁的线程会被挂起，JVM会尝试消除它身上的偏向锁，将锁恢复到标准的轻量级锁。(偏向锁只能在单线程下起作用)，其流程如图所示：

Paste_Image.png

偏向锁获取过程：

(1)访问Mark Word中偏向锁的标识是否设置成1，锁标志位是否为01——确认为可偏向状态。

(2)如果为可偏向状态，则测试线程ID是否指向当前线程，如果是，进入步骤(5)，否则进入步骤(3)。

(3)如果线程ID并未指向当前线程，则通过CAS操作竞争锁。如果竞争成功，则将Mark Word中线程ID设置为当前线程ID，然后执行(5)；如果竞争失败，执行(4)。

(4)如果CAS获取偏向锁失败，则表示有竞争。当到达全局安全点(safepoint)时获得偏向锁的线程被挂起，偏向锁升级为轻量级锁，然后被阻塞在安全点的线程继续往下执行同步代码。

(5)执行同步代码。

偏向锁的释放：

偏向锁的撤销在上述第四步骤中有提到。偏向锁只有遇到其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁，线程不会主动去释放偏向锁(不主动释放)。偏向锁的撤销，需要等待全局安全点(在这个时间点上没有字节码正在执行)，它会首先暂停拥有偏向锁的线程，判断锁对象是否处于被锁定状态，撤销偏向锁后恢复到未锁定(标志位为“01”)或轻量级锁(标志位为“00”)的状态。

轻量级锁

轻量级锁(Lightweight Locking)本意是在没有多线程竞争的前提下(即多线程交替执行互斥代码情况下)，减少传统的重量级锁使用操作系统互斥量产生的性能消耗，是为了减少多线程进入互斥的几率，并不是要替代互斥。 它利用了CPU原语Compare-And-Swap(CAS，汇编指令CMPXCHG)，尝试在进入互斥前，进行补救。通过上表我们可以知道00标记为轻量级锁，其流程：

Paste_Image.png

轻量级锁获取过程

(1)在代码进入同步块的时候，如果同步对象锁状态为无锁状态(锁标志位为“01”状态，是否为偏向锁为“0”)，虚拟机首先将在当前线程的栈帧中建立一个名为锁记录(Lock Record)的空间，用于存储锁对象目前的Mark Word的拷贝，官方称之为 Displaced Mark Word。这时候线程堆栈与对象头的状态如图2.1所示。

(2)拷贝对象头中的Mark Word复制到锁记录中。

(3)拷贝成功后，虚拟机将使用CAS操作尝试将对象的Mark Word更新为指向Lock Record的指针，并将Lock record里的owner指针指向object mark word。如果更新成功，则执行步骤(4)，否则执行步骤(5)。

(4)如果这个更新动作成功了，那么这个线程就拥有了该对象的锁，并且对象Mark Word的锁标志位设置为“00”，即表示此对象处于轻量级锁定状态，这时候线程堆栈与对象头的状态如图2.2所示。

(5)如果这个更新操作失败了，虚拟机首先会检查对象的Mark Word是否指向当前线程的栈帧，如果是就说明当前线程已经拥有了这个对象的锁，那就可以直接进入同步块继续执行。否则说明多个线程竞争锁，轻量级锁就要膨胀为重量级锁，锁标志的状态值变为“10”，Mark Word中存储的就是指向重量级锁(互斥量)的指针，后面等待锁的线程也要进入阻塞状态。 而当前线程便尝试使用自旋来获取锁，自旋就是为了不让线程阻塞，而采用循环去获取锁的过程。

Paste_Image.png

Paste_Image.png

轻量级锁释放过程

(1)通过CAS操作尝试把线程中复制的Displaced Mark Word对象替换当前的Mark Word。

(2)如果替换成功，整个同步过程就完成了。

(3)如果替换失败，说明有其他线程尝试过获取该锁(此时锁已膨胀)，那就要在释放锁的同时，唤醒被挂起的线程。

总结：

Paste_Image.png

Paste_Image.png

其他优化

(1)、适应性自旋(Adaptive Spinning)：

从轻量级锁获取的流程中我们知道，当线程在获取轻量级锁的过程中执行CAS操作失败时，是要通过自旋来获取重量级锁的。问题在于，自旋是需要消耗CPU的，如果一直获取不到锁的话，那该线程就一直处在自旋状态，白白浪费CPU资源。解决这个问题最简单的办法就是指定自旋的次数，例如让其循环10次，如果还没获取到锁就进入阻塞状态。但是JDK采用了更聪明的方式——适应性自旋，简单来说就是线程如果自旋成功了，则下次自旋的次数会更多，如果自旋失败了，则自旋的次数就会减少。

(2)、锁粗化

锁粗化的概念应该比较好理解，就是将多次连接在一起的加锁、解锁操作合并为一次，将多个连续的锁扩展成一个范围更大的锁。举个例子：

public class StringBufferTest {

StringBuffer stringBuffer = new StringBuffer();

public void append(){

stringBuffer.append("a");

stringBuffer.append("b");

stringBuffer.append("c");

}

}

这里每次调用stringBuffer.append方法都需要加锁和解锁，如果虚拟机检测到有一系列连串的对同一个对象加锁和解锁操作，就会将其合并成一次范围更大的加锁和解锁操作，即在第一次append方法时进行加锁，最后一次append方法结束后进行解锁。

(3)、锁消除

锁消除即删除不必要的加锁操作。根据代码逃逸技术，如果判断到一段代码中，堆上的数据不会逃逸出当前线程，那么可以认为这段代码是线程安全的，不必要加锁。看下面这段程序：

public class SynchronizedTest02 {

public static void main(String[] args) {

SynchronizedTest02 test02 = new SynchronizedTest02();

//启动预热

for (int i = 0; i < 10000; i++) {

i++;

}

long start = System.currentTimeMillis();

for (int i = 0; i < 100000000; i++) {

test02.append("abc", "def");

}

System.out.println("Time=" + (System.currentTimeMillis() - start));

}

public void append(String str1, String str2) {

StringBuffer sb = new StringBuffer();

sb.append(str1).append(str2);

}

}

虽然StringBuffer的append是一个同步方法，但是这段程序中的StringBuffer属于一个局部变量，并且不会从该方法中逃逸出去，所以其实这过程是线程安全的，可以将锁消除。下面是本地执行的结果：

Paste_Image.png

注：可能JDK各个版本之间执行的结果不尽相同，我这里采用的JDK版本为1.6

3、synchronized源码解析

4、深入分析Object.wait/notify实现机制

Paste_Image.png

Object.wait/notify实现机制在HotSpot虚拟机中，monitor采用ObjectMonitor实现。ObjectMonitor对象中有两个队列：_WaitSet 和 _EntryList，用来保存ObjectWaiter对象列表；_owner指向获得ObjectMonitor对象的线程。

处于等待锁block状态的线程，会被加入到entry set；处于wait状态的线程，会被加入到wait set；notify方法会获取_WaitSet列表中的第一个ObjectWaiter节点，根据不同的策略，将取出来的ObjectWaiter节点，加入到_EntryList或则通过Atomic::cmpxchg_ptr指令进行自旋操作cxq。

参考：

http://www.jianshu.com/p/f4454164c017

https://www.cnblogs.com/wewill/p/8058292.html