栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

【多线程学习四】锁原理及wait和notify原理进阶

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

【多线程学习四】锁原理及wait和notify原理进阶

Monitor

Java对象头,以32位虚拟机为例



实现原理

监视器/管程,当使用synchronized给对象上锁时(重量级),对象头的mark word就被设置指向monitor对象的指针

一个对象指向一个monitor,不会多个对象指向同一个monitor,monitor是由操作系统提供的

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

一个对象有多个线程要加锁,但是加锁的时间是错开的,可以使用轻量级锁进行优化(00)

轻量级锁对用户是透明的,语法仍是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,将替换前object的mark word值存入锁记录

  • cas替换成功后,object中存储了锁记录地址和状态00,表示该线程已给对象加锁

  • cas替换失败,有两种情况

    • 其他线程已给该对象加了轻量级锁,此时有竞争,进入锁膨胀过程

    • 自己执行了synchronized锁重入,再添加一条锁记录作为重入的计数

  • 当退出synchronized代码块时,如果有值为null的锁记录,表示有重入,这时重置锁记录,重入技术减一

  • 当退出synchronized代码块时,如果没有null的锁记录,使用cas将mark word的值恢复给锁对象

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

当锁重入时,每次都要用cas去用 锁记录 替换 markword,会影响性能

锁膨胀

当用cas给锁对象加轻量级锁的时候,操作失败,可能是因为已经有其他线程为此对象加上了轻量级锁了,这时就需要进行锁膨胀,将轻量级锁变为重量级锁

static Object obj = new Object();
public static void method1() {
 	synchronized( obj ) {
 		// 同步块
 	}
}
  • 当线程1给锁对象进行轻量级加锁时,线程0已经对该对象加了轻量级锁

  • 这时线程1给锁对象加锁失败,进入锁膨胀过程

    • 为object申请monitor锁,让object指向重量级锁地址
    • 线程1进入monitor的entrylist blocked

  • 当线程0解锁后,使用cas将mark word的值恢复给锁对象,失败。这时进入重量级解锁过程,即按照monitor地址找到monitor对象,将owner设置为null,唤醒entrylist中blocked线程
自旋优化

重量级锁竞争时,可以用自旋进行优化,如果当前线程自旋成功(即当前owner值为null,线程释放了锁),则当前线程可以避免阻塞

  • 自旋会占用CPU时间,多核自旋才能发挥优势
  • java6+后较为智能,如果对象刚刚的一次自旋操作成功过,会认为这次自旋成功的可能性也高,就会多自旋;反之少自旋/不自旋
  • java7+后不能控制是否开启自旋功能
偏向锁

轻量级锁的优化

java6引入的偏向锁:只有第一次使用cas将线程id设置到对象的mark word中,之后发现该线程id是自己的就表示没有竞争,不用重新cas,之后只要不发生竞争,该对象就归该线程id对应的线程所有

mark word存的不再是锁记录,而是线程id

  • 默认开启偏向锁,创建一个对象时,Mark word的值最后3位为101,而此时thread、epoch、age都为0
  • 偏向锁默认是延迟的,不会在程序启动时立即生效,可通过VM参数**-XX:BiasedLockingStartupDelay=0**来禁用延迟
  • 若果没有开启偏向锁,对象创建后mark word值最后3位为001,此时的hashcode、age值为0,第一次用到hashcode才会赋值

偏向锁解锁后,线程id仍存储在对象头中

在项目运行时添加-XX:-UseBiasedLocking禁用偏向锁

为什么打印了对象的hashCode后会禁用了对象的偏向锁?

撤销了对象的偏向状态,为了腾出位置给hashCode存值,需要清除线程id的字节码

调用了hashCode后使用偏向锁,得去掉禁用偏向锁的VM参数

当有其他线程使用偏向锁时,会将偏向锁升级为轻量级锁

调用wait/notify撤销偏向锁

批量重偏向

如果对象被多个线程访问,且没有竞争,这时偏向了线程1的对象仍有机会重新偏向线程2,重偏向会重置对象的线程id

当撤销偏向锁的阈值达到了20次后,jvm会给对象加锁时重新偏向至加锁线程

  • 先给对象加上偏向锁,偏向t1
  • 当t1线程执行完后,t2被唤醒,执行t2线程,由于偏向锁中的线程id还是t1的,所以t2执行时会撤销偏向锁,升级为轻量级锁,当撤销的阈值达到了20次后,对象的偏向状态会转给t2,实现重偏向操作
private static void test3() throws InterruptedException {
 	 Vector 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();
}
批量撤销

当撤销偏向锁阈值超过40次后,jvm会觉得自己判断失误,不应该偏向,所以整个类的所有对象都会变为不可偏向的,之后新创建的对象也不可偏向的

锁消除

线程默认是启动锁消除优化的,减小加锁带来的性能干扰

java -XX:-EliminateLocks -jar benchmarks.jar关闭锁消除优化

Wait/notify

  • Owner线程发现条件不满足时,调用wait方法,即可进入WaitSet变为WAITING状态
  • BLOCKED和WAITING的线程都处于阻塞状态,不占用CPU时间片
  • BLOCKED线程会在Owner释放锁时被唤醒
  • WAITING线程会在Owner调用notify/notifyAll时被唤醒,但唤醒后不意味着立刻获得锁,仍需进入entryList中重新竞争
原理

必须获得此对象的锁才能调用这几个方法

  • obj.wait()让进入object监视器的线程到waitSet等待
  • obj.notify()在object上正在waitSet等待的线程中挑一个唤醒
  • obj.notifyAll()让object上所有在waitSet等待的线程全部唤醒
final static Object obj = new Object();
public static void main(String[] args) {
 	new Thread(() -> {
 		synchronized (obj) {
 			log.debug("执行....");
 			try {
				 obj.wait(); // 让线程在obj上一直等待下去
 			} catch (InterruptedException e) {
 				e.printStackTrace();
 			}
 			log.debug("其它代码....");
		 }
		 }).start();
 	new Thread(() -> {
         synchronized (obj) {
             log.debug("执行....");
             try {
             obj.wait(); // 让线程在obj上一直等待下去
             } catch (InterruptedException e) {
             e.printStackTrace();
             }
			 log.debug("其它代码....");
 			}
 		}).start();
 		// 主线程两秒后执行
 	sleep(2);
 	log.debug("唤醒 obj 上其它线程");
 	synchronized (obj) {
 		obj.notify(); // 唤醒obj上一个线程
		 // obj.notifyAll(); // 唤醒obj上所有等待线程
	 }
}

notify的一种结果

notifyAll的结果

  • wait()无限制等待,直到notify通知
  • wait(long n) 有时限等待,到n毫秒后结束等待/被notify通知

notify 只能随机唤醒一个 WaitSet 中的线程,这时如果有其它线程也在等待,那么就可能唤醒不了正确的线程,称之为虚假唤醒

sleep()&wait()

不同

  • sleep是Thread方法,wait是Object方法
  • sleep不会释放锁,wait会释放锁
  • sleep 不用强制与synchronized配合使用,wait需要和synchronized搭配一起使用

相同

sleep和wait状态都是TIMED_WAITING

wait()和notify()的正确姿势

用 notifyAll 仅解决某个线程的唤醒问题,但使用 if + wait 判断仅有一次机会,一旦条件不成立,就没有重新判断的机会了

解决方法,用 while + wait,当条件不成立,再次 wait

new Thread(() -> {
     synchronized (room) {
         log.debug("有烟没?[{}]", hasCigarette);
         while (!hasCigarette) {
             log.debug("没烟,先歇会!");
             try {
             room.wait();
             } catch (InterruptedException e) {
             e.printStackTrace();
             }
    	 }
 	log.debug("有烟没?[{}]", hasCigarette);
     if (hasCigarette) {
     log.debug("可以开始干活了");
     } else {
          log.debug("没干成活...");
     }
     }
	}, "小南").start();
new Thread(() -> {
     synchronized (room) {
         Thread thread = Thread.currentThread();
         log.debug("外卖送到没?[{}]", hasTakeout);
         if (!hasTakeout) {
         	log.debug("没外卖,先歇会!");
             try {
             room.wait();
             } catch (InterruptedException e) {
             e.printStackTrace();
             }
         }
         log.debug("外卖送到没?[{}]", hasTakeout);
         if (hasTakeout) {
         log.debug("可以开始干活了");
         } else {
         log.debug("没干成活...");
         }
     }
	}, "小女").start();
sleep(1);
new Thread(() -> {
     synchronized (room) {
         hasTakeout = true;
         log.debug("外卖到了噢!");
         room.notify();
     }
}, "送外卖的").start();

模板
synchronized(lock) {
     while(条件不成立) {
     lock.wait();
     }
     // 干活
  }
//另一个线程
synchronized(lock) {
 	lock.notifyAll();
}
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/978475.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号