Java学习笔记——并发编程（二）

一、Monitor概念

1.Java对象头

以32位虚拟机为例
      普通对象

      数组对象

      其中，Mark Word的结构为

2.Monitor工作原理

      Monitor被翻译为监视器或管程
      每个Java对象都可以关联一个Monitor对象，如果使用synchronized给对象上锁(重量级)之后，该对象头的Mark Word中就被设置指向Monitor对象的指针
      Monitor结构如下

• 刚开始Monitor中Owner为null
• 当Thread-2执行synchronized(obj)就会将Monitor的所有者Owner置为Thead-2，Monitor中只能有一个Owner
• 在Thread-2上锁的过程中，如果Thread-3，Thread-4，Thread-5也来执行synchronized(obj)，就会进入EntryList BLOCKED
• Thread-2执行完同步代码块的内容，然后唤醒EntryList中等待的线程来竞争锁，竞争时是非公平的
• 图中WaitSet中的Thread-0，Thread-1是之前获得过锁，但条件不满足进入WAITING状态的线程，后面讲wait-notify时会分析

注意

• synchronized必须是进入同一个对象的monitor才有上述的效果
• 不加synchronized的对象不会关联监视器，不遵从以上规则

3.原理之synchronized

      从字节码的角度来分析一下Java对synchronized锁的实现

static final Object lock = new Object();
static int counter = 0;

public static void main(String[] args){
   
	synchronized(lock){
   
		counter++;
	}
}

      对应的字节码为

public static void main(String[] args);
	descriptor: ([Ljava/lang/String;)V
	flags:ACC_PUBLIC,ACC_STATIC
	Code:
		stack=2,locals=3,args_size=1
		0:getstatic    #2   //<- lock引用(synchronized开始)
		3：dup
		4:astore_1          //lock引用 -> slot 1
		5:monitorenter      //将lock对象MarkWord置为Monitor指针
		6:getstatic    #3   //<- i
		9:iconst_1          //准备常数1
		10：iadd            //+1
		11:putstatic   #3   //-> i
		14:aload_1          //<- lock引用
		15:monitorexit      //将lock对象MarkWord重置，唤醒EntryList
		16:goto        24
		19:astore_2         //e -> slot 2
		20:aload_1          //<- lock引用
		21:monitorexit      //将lock对象MarkWord重置，唤醒EntryList
		22:aload_2          //<- slot 2(e)
		23:athrow           //throw e
		24:return
	  Exception table:
	  	from	to	target	type
	  	   6    16      19   any
	  	  19    22      19   any		

4.原理之synchronized进阶

1>轻量级锁

轻量级锁使用场景
      如果一个对象虽然有多线程访问，但多线程访问的时间是错开的（也就是没有竞争），那么可以使用轻量级锁来优化。
如果有竞争，轻量级锁会升级为重量级锁。
轻量级锁对使用者是透明的，即语法仍然是synchronized
假设有两个方法同步块，利用同一个对象加锁

static final Object obj = new Object();
public static void method1(){
   
	synchronized(obj){
   
		//同步块A
		method2();
	}
}
public static void method2(){
   
	synchronized(obj){
   
		//同步块B
	}
}

分析上述代码的加锁流程

• 创建锁记录(Lock Record)对象，每个线程栈的栈帧都会包含一个锁记录的结构，内部可以存储锁定对象的Mark Word
  

• 让锁记录中Object reference指向锁对象，并尝试用cas替换Object的Mark Word，将Mark Word的值存入锁记录
  

• 如果cas替换成功，对象头中存储了锁记录地址和状态00，表示由该线程给对象加锁，这时图示如下
  

• 如果cas失败，有两种情况

  • 如果是其他线程已经持有了该Object的轻量级锁，这时表明有竞争，进入锁膨胀过程
  • 如果是自己执行了synchronized锁重入，那么再添加一条Lock Record作为重入的计数
    

• 当退出synchronized代码块(解锁时)如果有取值为null的锁记录，表示有重入，这时重置锁记录，表示重入计数减一
  

• 当退出synchronized代码块(解锁时)锁记录的值不为null，这时使用cas将Mark Word的值恢复给对象头

  • 成功，则解锁成功
  • 失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程

2>锁膨胀

      如果在尝试加轻量级锁的过程中，cas操作无法成功，这时一种情况就是有其他线程为此对象加上了轻量级锁(有竞争)，这时需要进行锁膨胀，将轻量级锁变为重量级锁

static Object obj = new Object();
public static void method1(){
   
	synchronized(obj){
   
		//同步块
	}
}

• Thread-1进行轻量级加锁时，Thread-0已经对该对象加了轻量级锁
  

• 这时Thread-1加轻量级锁失败，进入锁膨胀流程

  • 即为Object对象申请Monitor锁，让Object指向重量级锁地址
  • 然后自己进入Monitor的EntryList BLOCKED
    

• 当Thread-0退出同步块解锁时，使用cas将Mark Word的值恢复给对象头，失败。这时会进入重量级解锁流程，即按照Monitor地址找到Monitor对象，设置Owner为null，唤醒EntryList中BLOCKED线程

3>自旋优化

重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功(即这时候持锁线程已经退出了同步块，释放了锁)，这时当前线程就可以避免阻塞。

• 自旋重试成功的情况
  

• 自旋重试失败的情况
  
  注意
        自旋重试在多核cpu下才有效

• 在Java6之后自旋锁是自适应的，比如对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会高，就多自旋几次；反之，就少自旋甚至不自旋，总之，比较智能。

• 自旋会占用CPU时间，单核cpu自旋就是浪费，多核cpu自旋才能发挥优势

• Java7之后不能控制是否开启自旋功能

4>偏向锁

      轻量级锁在没有竞争时(就自己这个线程)，每次重入仍然需要执行cas操作
      Java6中引入了偏向锁来做进一步优化：只有第一次使用cas将线程ID设置到对象的Mark Word头，之后发现这个线程ID是自己的就表示没有竞争，不用重新cas。以后只要不发生竞争，这个对象就归该线程所有。例如：

static final Object obj = new Object();
public static void m1(){
   
	synchronized(obj){
   
		//同步块A
		m2();
	}
}
public static void m2(){
   
	synchronized(obj){
   
		//同步块B
		m3();
	}
}
public static void m3(){
   
	synchronized(obj){
   
		//同步块C
	}
}

偏向状态
回忆一下对象头格式

一个对象创建时：

• 如果开启了偏向锁(默认开启)，那么对象创建后，Mark Word值为0x05即最后3位为101，这时它的thread、epoch、age都为0
• 偏向锁默认是延迟的，不会在程序启动时立即生效，如果想避免延迟，可以加VM参数-xx:BiasedLockingSartupDelay=0