• 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++;
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

          对应的字节码为

    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		

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    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
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    分析上述代码的加锁流程

    • 创建锁记录(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){
		//同步块
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    • 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之后不能控制是否开启自旋功能

    Java并发编程学习笔记.
    zip 0星 超过10%的资源 1.94MB
    下载

    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
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    在这里插入图片描述
    在这里插入图片描述
    偏向状态
    回忆一下对象头格式
    在这里插入图片描述
    一个对象创建时：

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

    撤销偏向锁的三种情况

    • 其他线程使用对象
      线程在使用完偏向锁后不会主动释放，需要在其他线程也要获取这个锁时，会设置对象上的锁为不可偏向状态，并且升级为轻量级锁
    private static void test2() throws InterruptedException{
	
	Dog d = new Dog();
	Thread t1 = new Thread(()->{
		synchronized(d){
			log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
		}
		synchronized(TestBiased.class){
			TestBiased.class.notify();
		}
		//如果不用wait/notify，使用join必须打开下面的注释
		//因为：t1线程不能结束，否则底层线程可能被jvm重用作为t2线程，底层线程id是一样的
		/*try{
			System.in.read();
		}catch(IOException e){
			e.printStackTrace();
		}
		*/
	},"t1");
	t1.start();
	Thread t2 = new Thread(()->{
		synchronized(TestBiased.class){
			try{
				TestBiased.class.wait();
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
		log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
		synchronized(d){
			log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
		}
		log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
	},"t1");
	t1.start();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    输出

    [t1] - 00000000 00000000 00000000 00000000 00011111 01000001 00010000 00000101
[t2] - 00000000 00000000 00000000 00000000 00011111 01000001 00010000 00000101
[t2] - 00000000 00000000 00000000 00000000 00011111 10110101 11110000 01000000
[t2] - 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001

    • 1
    • 2
    • 3
    • 4
    • 调用对象hashCode
      调用了对象的hashCode,但偏向锁的对象Mark Word中存储的是线程id，如果调用hashCode会导致偏向锁被撤销。偏向锁和hashCode是互斥存在的；轻量级锁的hashCode存储在线程栈帧的锁记录中；重量级锁的hashCode存储在Monitor对象中！
      • 轻量级锁会在锁记录中记录hashCode
      • 重量级锁会在Monitor中记录hashCode

    在调用hashCode后使用偏向锁，记得去掉-xx:-UseBiasedLocking
    输出
    在这里插入图片描述

    • 调用wait/notify

    批量重偏向
          如果对象虽然被多个线程访问，但没有竞争，这时偏向了线程T1的对象仍有机会重新偏向T2，重偏向会重置对象的ThreadID。
          当撤销偏向锁阈值超过20次后，jvm会这样觉得，我是不是偏向错了呢？于是会在给这些对象加锁时重新偏向至加锁线程。

    Java并发编程学习笔记.rar
    rar 0星 超过10%的资源 187.0B
    下载
    private static void test3() throws InterruptedException{
	Vector<Dog> list = new Vector<>();
	Thread t1 = new Thread(()->{
		for(int i = 0;i < 30;i++){
			Dog d = new Dog();
			list.add(d);
			synchronized(d){
				log.debug(i+"\t"+ClassLayout.parseInstance(d).toPrintableSimple(true));
			}
		}
		synchronized(list){
			list.notify();
		}
	},"t1");
	t1.start();
	
	Thread t2 = new Thread(()->{
		synchronized(list){
			try{
				list.wait();
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
		log.debug("=====================>");
		for(int i = 0;i < 30;i++){
			Dog d = list.get(i);
			log.debug(i+"\t"+ClassLayout.parseInstance(d).toPrintableSimple(true));
			synchronized(d){
				log.debug(i+"\t"+ClassLayout.parseInstance(d).toPrintableSimple(true));
			}
			log.debug(i+"\t"+ClassLayout.parseInstance(d).toPrintableSimple(true));
		}
	},"t2");
	t2.start();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    输出分析

    //内容较多，取输出结果部分进行分析
[t1] - 0   00000000 00000000 00000000 00000000 00011111 11101011 01000000 00000101
[t1] - 1   00000000 00000000 00000000 00000000 00011111 11101011 01000000 00000101
[t1] - 2   00000000 00000000 00000000 00000000 00011111 11101011 01000000 00000101
...
[t1] - 29  00000000 00000000 00000000 00000000 00011111 11101011 01000000 00000101
[t2] - =====================>
[t2] - 0   00000000 00000000 00000000 00000000 00011111 11101011 01000000 00000101
[t2] - 0   00000000 00000000 00000000 00000000 00100000 01111010 11110110 01110000
[t2] - 0   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 1   00000000 00000000 00000000 00000000 00011111 11101011 01000000 00000101
[t2] - 1   00000000 00000000 00000000 00000000 00100000 01111010 11110110 01110000
[t2] - 1   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
...
[t2] - 18  00000000 00000000 00000000 00000000 00011111 11101011 01000000 00000101
[t2] - 18  00000000 00000000 00000000 00000000 00100000 01111010 11110110 01110000
[t2] - 18  00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 19  00000000 00000000 00000000 00000000 00011111 11101011 01000000 00000101
[t2] - 19  00000000 00000000 00000000 00000000 00011111 11101011 01010001 00000101
[t2] - 19  00000000 00000000 00000000 00000000 00011111 11101011 01010001 00000101
...
[t2] - 29  00000000 00000000 00000000 00000000 00011111 11101011 01000000 00000101
[t2] - 29  00000000 00000000 00000000 00000000 00011111 11101011 01010001 00000101
[t2] - 29  00000000 00000000 00000000 00000000 00011111 11101011 01010001 00000101

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

          线程t1-0到线程t1-29这30个线程加的都是偏向锁；线程t2-0到线程t2-18在加锁前是偏向于线程t1的锁，加的锁升级为了轻量级锁(末两位为00)，离开时(末三位为001)即置为不可偏向；从线程t2-19开始，加锁中和离开时末三位都是101，这个时候是偏向于线程2的锁。
    批量撤销
          当撤销偏向锁阈值超过40次后，jvm会这样觉得，自己确实偏向错了，根本就不该偏向。于是整个类的所有对象都会变为不可偏向的，新建的对象也是不可偏向的。

    static Thread t1,t2,t3;
private static void test4() throws InterruptedException{
	Vector<Dog> list = new Vector<>();
	
	int loopNumber = 39;
	t1 = new Thread(()->{
		for(int i = 0;i < loopNumber;i++){
			Dog d = new Dog();
			list.add(d);
			synchronized(d){
				log.debug(i+"\t"+ClassLayout.parseInstance(d).toPrintableSimple(true));
			}
		}
		LockSupport.unpark(t2);
	},"t1");
	t1.start();
	
	t2 = new Thread(()->{
		LockSupport.park();
		log.debug("=====================>");
		for(int i = 0;i < loopNumber;i++){
			Dog d = list.get(i);
			log.debug(i+"\t"+ClassLayout.parseInstance(d).toPrintableSimple(true));
			synchronized(d){
				log.debug(i+"\t"+ClassLayout.parseInstance(d).toPrintableSimple(true));
			}
			log.debug(i+"\t"+ClassLayout.parseInstance(d).toPrintableSimple(true));
		}
		LockSupport.unpark(t3);
	},"t2");
	t2.start();
	
	t3 = new Thread(()->{
		LockSupport.park();
		log.debug("=====================>");
		for(int i = 0;i < loopNumber;i++){
			Dog d = list.get(i);
			log.debug(i+"\t"+ClassLayout.parseInstance(d).toPrintableSimple(true));
			synchronized(d){
				log.debug(i+"\t"+ClassLayout.parseInstance(d).toPrintableSimple(true));
			}
			log.debug(i+"\t"+ClassLayout.parseInstance(d).toPrintableSimple(true));
		}
	},"t3");
	t3.start();
	
	t3.join();
	log.debug(ClassLayout.parseInstance(new Dog()).toPrintableSimple(true));
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49

    输出

    //内容较多，取输出结果部分进行分析
[t1] - 0   00000000 00000000 00000000 00000000 00011111 01011110 00010000 00000101
[t1] - 1   00000000 00000000 00000000 00000000 00011111 01011110 00010000 00000101
[t1] - 2   00000000 00000000 00000000 00000000 00011111 01011110 00010000 00000101
...
[t1] - 38  00000000 00000000 00000000 00000000 00011111 01011110 00010000 00000101
[t2] - =====================>
[t2] - 0   00000000 00000000 00000000 00000000 00011111 01011110 00010000 00000101
[t2] - 0   00000000 00000000 00000000 00000000 00011111 11111001 11110101 11111000
[t2] - 0   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 1   00000000 00000000 00000000 00000000 00011111 01011110 00010000 00000101
[t2] - 1   00000000 00000000 00000000 00000000 00011111 11111001 11110101 11111000
[t2] - 1   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
...
[t2] - 18  00000000 00000000 00000000 00000000 00011111 01011110 00010000 00000101
[t2] - 18  00000000 00000000 00000000 00000000 00011111 11111001 11110101 11111000
[t2] - 18  00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 19  00000000 00000000 00000000 00000000 00011111 01011110 00010000 00000101
[t2] - 19  00000000 00000000 00000000 00000000 00011111 01011110 01100001 00000101
[t2] - 19  00000000 00000000 00000000 00000000 00011111 01011110 01100001 00000101
...
[t2] - 38  00000000 00000000 00000000 00000000 00011111 01011110 00010000 00000101
[t2] - 38  00000000 00000000 00000000 00000000 00011111 01011110 01100001 00000101
[t2] - 38  00000000 00000000 00000000 00000000 00011111 01011110 01100001 00000101
[t3] - =====================>
[t3] - 0   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t3] - 0   00000000 00000000 00000000 00000000 00100000 00001001 11101111 01001000
[t3] - 0   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
...
[t3] - 18   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t3] - 18   00000000 00000000 00000000 00000000 00100000 00001001 11101111 01001000
[t3] - 18   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t3] - 19   00000000 00000000 00000000 00000000 00011111 01011110 01100001 00000101
[t3] - 19   00000000 00000000 00000000 00000000 00100000 00001001 11101111 01001000
[t3] - 19   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
...
[t3] - 38   00000000 00000000 00000000 00000000 00011111 01011110 01100001 00000101
[t3] - 38   00000000 00000000 00000000 00000000 00100000 00001001 11101111 01001000
[t3] - 38   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[main] - 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

          t1线程循环了39次，给这39个对象都加上了偏向锁，他们刚开始都是偏向于t1线程的。
          然后t2线程开始运行，发现从t1到t2，就不能偏向了，一开始先一个一个撤销，变成了轻量级锁，解锁之后变成了001，可偏向状态已经被撤销掉了；一直到18，从19开始，变成偏向t2的锁，一直到38。(批量重偏向，阈值：20)
          接下来，t3线程运行了，前面18个对象已经是不可偏向的了，加的也都是轻量级锁，解锁之后仍然是不可偏向的；第19个对象，一开始偏向t2线程，但是现在要从t2线程偏向到t3线程，所以要撤销掉，升级为轻量级锁，解锁后末三位为001；再往下，一直到38，都是撤销，没有批量重偏向了。从0到38.已经有39次撤销操作了，到第40次撤销操作时，jvm就认为这个类竞争比较激烈，把整个类的所有对象都变为不可偏向状态。(批量撤销，阈值40)
          所以在主线程里再创建对象时，末三位为001,即不可偏向状态。

    如果将loopNumber的值改为38
    输出

    ...
[main] - 00000000 00000000 00000000 00000000 00000000 00000000 00000001 00000101

    • 1
    • 2

    小结

          从优先级上进行划分，有偏向锁会采用偏向锁；如果其他线程用了这个锁，会撤销偏向锁，变成轻量级锁；如果加了轻量级锁，但是有竞争发生，锁升级为重量级锁。

    学习视频
    黑马程序员全面深入学习Java并发编程，JUC并发编程全套教程

  • 相关阅读:
    登榜丨酷雷曼获“科技型中小企业”国家级认定
    java家庭理财收支管理系统
    java进阶学习路线
    “JavelinRecordDistance“ app Tech Support（URL）
    Redis限流实践：实现用户消息推送每天最多通知2次的功能
    交流回馈老化测试负载如何实现这些功能的
    C# OpenCvSharp 通道分离
    Qt 样式表大全整理
    Ribbon 添加右侧区域菜单项
    【递归算法】递归算法的快速入门
  • 原文地址：https://blog.csdn.net/l903445981/article/details/126023653