CPU缓存和内存屏障
承上启下
上篇博客介绍了现在JDK弃用的api，这篇博客介绍现在使用的两种api
wait/notify机制
这些方法只能由(同一对象锁)的持有者线程调用，也就是卸载同步块里面，否则会抛出IllegalMonitorStateException异常。一定要在同步代码段
wait方法导致当前线程等待，加入该对象的等待集合中，并且放弃当前持有的对象锁，notify/notifyAll方法唤醒一个或所有的正在等待这个对象锁的线程
package demo2;
public class wait {
public static Object baozidian=null;
public void waitNotifyTest() throws Exception{
//启动线程
new Thread(()->{
if(baozidian==null){ //如果没有包子，则进入等待
synchronized (this){
try{
System.out.println("1.进入等待");
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println("2.买到包子，回家");
}).start();
//3秒之后，生产一个包子
Thread.sleep(3000L);
baozidian=new Object();
synchronized (this){
this.notifyAll();
System.out.println("3.通知消费者");
}
}
public static void main(String[] args) throws Exception {
new wait().waitNotifyTest();
}
}
产生死锁情况
注意，虽然会wait自动解锁，但是对顺序有要求，如果在notify被调用之后，才开始wait方法的调用，线程会永远处理waiting状态
package demo2;
public class wait {
public static Object baozidian=null;
public void waitNotifyTest() throws Exception{
//启动线程
new Thread(()->{
if(baozidian==null){ //如果没有包子，则进入等待
try{
Thread.sleep(5000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (this){
try{
System.out.println("1.进入等待");
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println("2.买到包子，回家");
}).start();
//3秒之后，生产一个包子
Thread.sleep(3000L);
baozidian=new Object();
synchronized (this){
this.notifyAll(); //唤醒所有的线程
System.out.println("3.通知消费者");
}
}
public static void main(String[] args) throws Exception {
new wait().waitNotifyTest();
}
}
3秒之后在notify被调用，不过这时候wait方法没有被调用，5秒之后在进行被调用，所以线程会永远处理waiting状态
park/unpark机制
线程调用park则等待"许可",unpark方法为指定线程提供"许可(permit)"
不要求park和unpark的调用顺序
多次调用unpark之后，在调用park，线程会直接运行，但不会叠加，也就是说，连续多次调用park方法，第一次会拿到"许可"直接运行，后续调用会进入等待
package demo2;
import java.util.concurrent.locks.LockSupport;
public class park {
public static Object baozidian=null;
public void parkUnparkTest() throws Exception{
try{ //唤醒的程序已经被执行过了
Thread.sleep(5000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
//启动线程
Thread consumerThread=new Thread(()->{
if(baozidian==null){
System.out.println("1.进入等待");
LockSupport.park();
}
System.out.println("2.买到包子，回家");
});
consumerThread.start();
//3秒之后，生产一个包子
Thread.sleep(3000L);
baozidian=new Object();
LockSupport.unpark(consumerThread);
System.out.println("3.通知消费者");
}
public static void main(String[] args) throws Exception {
new park().parkUnparkTest();
}
}
产生死锁情况
不会对锁进行释放，只是操作线程
package demo2;
import java.util.concurrent.locks.LockSupport;
public class park {
public static Object baozidian=null;
public void parkUnparkTest() throws Exception{
try{ //唤醒的程序已经被执行过了
Thread.sleep(5000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
//启动线程
Thread consumerThread=new Thread(()->{
if(baozidian==null){
System.out.println("1.进入等待");
// 当前线程拿到锁，然后挂起
synchronized (this){ //没有被释放，一直处理被挂起的状态
LockSupport.park();
}
}
System.out.println("2.买到包子，回家");
});
consumerThread.start();
//3秒之后，生产一个包子
Thread.sleep(3000L);
baozidian=new Object();
//争取到锁以后，在恢复consumerThread
synchronized (this){
LockSupport.unpark(consumerThread);
}
System.out.println("3.通知消费者");
}
public static void main(String[] args) throws Exception {
new park().parkUnparkTest();
}
}
警告!之前代码中用if语句来判断，是否进行等待状态，是错误的
官方建议应该在while循环中检查等待条件，原因是处于等待状态的线程可能会收到错误警报和伪唤醒，如果不在循环中检查等待条件，程序就会在没有满足结束条件的情况下推出。伪唤醒是指线程并非因为notify，notifyall，unpark等api调用而唤醒，是更底层原因导致的
今天就先分享到这里，之后还有一系列的课
