多线程notify()是有序唤醒线程的!!有序的!!有序的!!
重要的事情说三遍 就是有序的唤醒等待的线程的
之前网上有很多说notify是随时唤醒线程的 是错的
这里我们用两个例子来举证一下 ,这种方式比源码来的简单
当然如果不够详细的话 大家可以去研究一下 wait和notify的源码,这里我就不贴出来了
package com.zmkj.admin.test;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;
/**
* 研究 notify 唤醒线程的顺序 有序?随机?
*
* @author sunminghao
*/
public class NotifySequence {
//等待列表, 用来记录等待的顺序
private static List<String> waitList = new LinkedList<>();
//唤醒列表, 用来唤醒的顺序
private static List<String> notifyList = new LinkedList<>();
private static Object lock = new Object();
public static void main(String[] args) throws InterruptedException {
//创建10个线程
for(int i=0;i<10;i++){
String threadName = Integer.toString(i);
new Thread(() -> {
synchronized (lock) {
String cthreadName = Thread.currentThread().getName();
System.out.println("线程 ["+cthreadName+"] 正在等待.");
waitList.add(cthreadName);
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程 ["+cthreadName+"] 被唤醒了.");
notifyList.add(cthreadName);
}
},threadName).start();
TimeUnit.MILLISECONDS.sleep(50);
}
TimeUnit.SECONDS.sleep(1);
for(int i=0;i<10;i++){
synchronized (lock) {
System.out.println("唤醒一个线程");
lock.notify();
//TODO 1
TimeUnit.MILLISECONDS.sleep(10);
}
//TODO 2
// System.out.println("释放一个锁");
// TimeUnit.MILLISECONDS.sleep(10);
}
TimeUnit.SECONDS.sleep(1);
System.out.println("wait顺序:"+waitList.toString());
System.out.println("唤醒顺序:"+notifyList.toString());
}
/**
* 当我们 分别注释 todo 1 和 2
* 的时间sleep的时候 我们会发现不同的效果
* 当 1 部分代码有效的时候 是无序随机的唤醒线程
* 当 2 部分代码有效的时候 是有序的唤醒线程
*
* 这就要问个为什么了,为什么呢?
* 为什么大多说人都认为notify是随机唤醒线程的呢?
* 这个时候你是不是在想 毕竟notify()并没有制定需要唤醒的线程啊 这么说也没问题 接下来看原因
*
* 一问:notify是立即释放锁的吗?
* 首先研究一下 WaitAndNotify 类方法,上一篇文章
*
* https://blog.csdn.net/qq_34129814/article/details/117222339
*
* 答案是 不是的
*
* 二问:为啥 一行代码 位置的不同 引发的结果天壤之别
*
* 细心的话 你会注意到我们 在外层加了一个synchronized 锁
*
*
* lock.notify();去唤醒等待线程, 我们假设唤醒了线程A;
* 但是因为后面还要执行TimeUnit.MILLISECONDS.sleep(10)所以lock锁并没有被释放!
* 当TimeUnit.MILLISECONDS.sleep(10)执行完毕后, lock被释放,
*
* 此时被唤醒的线程A想获取lock,
* 但是我们的for循环中synchronized (lock)也想继续获取lock,
* 于是两者发生了锁竞争.
*
* 由于synchronized实际上不是公平锁,其锁竞争的机制具有随机性
* 这就导致了最终, 我们看到的结果好像是随机的!
* 当我们把TimeUnit.MILLISECONDS.sleep(10);移出synchronized同步块后
* lock锁立即被释放了,
* 并且紧跟的 TimeUnit.SECONDS.sleep(1)确保被唤醒的线程能够获得lock锁立刻执行,
* 所以, 我们看到的结果才是正确的!
*
* 具体原因 wait 内部采用了队列 具有公平性 是按照顺序插入的
* 而notify是顺序执行的。所以就先进先出
*
* 结论: 有序的!!!!
*
*/
}
一问:notify是立即释放锁的吗?
首先研究一下 WaitAndNotify 类方法,上一篇文章
https://blog.csdn.net/qq_34129814/article/details/117222339
二问:为啥 一行代码 位置的不同 引发的结果天壤之别 一个是有序 一个是无序?