/**
* waitSet
* 通过JVM虚拟机实现的，调用wait方法，会将此线程放入到wait set中，然后放弃锁(对某些资源的声明)
* 1：所有的对象都会有一个wait set,用来存放调用了该对象wait方法之后进入block状态线程
* 2：线程被notify之后，并一定立即执行
* 3:线程被唤醒顺序不固定
* 4：线程被唤醒后，必须重新获取锁(该线程执行到的"位置"是被记录下来的，而不是从 synchronized (LOCK) 开始再次执行一遍)
*/
public class _14WaitSet {
private final static Object LOCK = new Object();
/*
每个类都有一个waitSet，存放wait的线程。
his method causes the current thread (call it <var>T</var>) to place itself in the wait set for this object
and then to relinquish any and all synchronization claims on this object.
他的方法导致当前线程(调用它<var>T</var>)将自己置于此对象的 wait set 中，然后放弃此对象上的任何和所有同步声明。
*/
public static void main(String[] args) {
IntStream.rangeClosed(1, 10).forEach(i ->
new Thread(() -> {
synchronized (LOCK) {
try {
Optional.of(Thread.currentThread().getName() + " will come to wait set").ifPresent(System.out::println);
LOCK.wait();
Optional.of(Thread.currentThread().getName() + " will leave to wait set").ifPresent(System.out::println);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start());
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (LOCK) {
IntStream.rangeClosed(1, 10).forEach(i -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
LOCK.notify();
});
}
}
public static void work() {
System.out.println("加锁前执行");
synchronized (LOCK) {
System.out.println("抢到锁后执行");
try {
System.out.println("wait前执行");
LOCK.wait();
System.out.println("wait后执行");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
* 4：线程被唤醒后，必须重新获取锁(该线程执行到的"位置"是被记录下来的，而不是从 synchronized (LOCK) 开始再次执行一遍)
*/
@Test
public void test1() throws InterruptedException {
new Thread(() -> work()).start();
Thread.sleep(3000);
synchronized (LOCK) {
LOCK.notify();
}
Thread.sleep(10000);
}
}
