wait、notify 方法
wait 和 我们前面学习的sleep、join方法一样，也是让线程阻塞，但是其可以被notify方法唤醒，但是sleep是被Interrupt给提前唤醒或者指定时间过了之后自动被唤醒，并且会抛出异常。且 join 是一个线程等待另一个线程，并且要 被等待的线程彻底执行完成之后，等待的线程才会从阻塞的中被唤醒重新执行。
wait方法在使用时，要和synchronized一起搭配使用，因为其是先对调用它的对象进行解锁，阻塞，在被唤醒之后，在进行加锁操作。
public class Test {
public static void main(String[] args) throws InterruptedException {
Object locker1 = new Object();
Thread t = new Thread(()->{
System.out.println("wait之前");
synchronized (locker1) { // 加锁
try {
locker1.wait(); // 进入wait方法解锁，出wait方法加锁
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
System.out.println("wait之后");
});
t.start();
// 为了让t线程先wait阻塞等待，得先休眠主线程一会：
// 可以使用sleep方法，也可以使用IO的方法阻塞
Thread.sleep(1000);
System.out.println("输入任意内容，唤醒t线程");
Scanner scanner = new Scanner(System.in);
scanner.next();
// 要出wait方法就需要notify进行唤醒操作
synchronized (locker1) {
locker1.notify();
}
}
}
注意：
1、在Java中，wait 和 notify 方法一定是和 synchronized 一起使用的。
2、在1的基础上，四者的进行加锁解锁的操作一定是针对同一个锁对象。
3、notify 的唤醒操作一定是在 wait 之前才能有效的唤醒。如果先执行了 notify 的唤醒操作，但是 还没有执行wait的阻塞操作的话，那么线程就一直会阻塞，但是 notify 的唤醒操作对线程本身是不会有影响的。
4、wait 和 notify 方法是 Object 对象的方法，即所有对象都可以使用这两个方法。
5、如果有多个线程处于 wait 的阻塞状态，那么 notify 一次只能随机唤醒一个线程。如果想要全部唤醒的话，得使用 notifyAll 方法。当然，也可以使用 notifyAll 去唤醒一个线程。
6、wait 和 join一样，也提供了最大等待时间。当超出这个最大等待时间时，被 wait 方法阻塞的线程将不会在处于阻塞状态。
public class Test {
public static void main(String[] args) throws InterruptedException {
Object locker = new Object();
Thread t = new Thread(()->{
System.out.println("wait之前");
synchronized (locker) {
try {
locker.wait(5000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
System.out.println("wait之后");
System.out.println("t线程结束");
});
t.start();
Thread.sleep(1000);
System.out.println("输入任意内容，唤醒t线程");
Scanner scanner = new Scanner(System.in);
scanner.next();
synchronized (locker) {
locker.notify();
}
}
}
当我们迟迟没有去输入值时，如果已经超过了 wait 的最大阻塞时间的话， wait 便不会去阻塞 t 线程了，而是会让其继续执行下去，即使我们后续再次输入值来执行 notify 的唤醒操作，也不再有用了。
7、当一个线程执行到 wait 之后，这个锁被释放了，也就意味着有别的线程可以使用这把锁了。
多线程练习
到此为止，我们已经学习了不少的多线程知识，现在我们就来练习一下。
题目：
有三个线程：t1、t2、t3，三者分别打印A、B、C，现在我们需要打印10次ABC。
思路：
1、既然打印有先后顺序，那么我们肯定是可以通过手动控制sleep 的休眠时间来决定的。
2、刚刚我们学习了 wait 和 notify ，应该是可以想到这个应用场景的，完全对上了。一个 打印完A之后，唤醒另一个线程，打印B，接着唤醒另一个线程打印C，最后 t3线程唤醒 t1线程，就这样相互唤醒打印，而 main 线程用来唤醒 t1 线程开始最初的打印即可。
代码实现：
1、暴力-sleep：
public class Test {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.print("A");
}
});
Thread t2 = new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.print("B");
}
});
Thread t3 = new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("C");
}
});
t1.start();
Thread.sleep(10); // 确保 t1是最先执行的
t2.start();
Thread.sleep(10); // 确保 t2比t1后执行，比t3先执行
t3.start();
}
}
注意：这里使三个线程的执行顺序的确定，其休眠的时间不能过长，否则不好衔接。
2、wait-notify版本：
public class Test {
public static void main(String[] args) throws InterruptedException {
Object locker1 = new Object();
Object locker2 = new Object();
Object locker3 = new Object();
Thread t1 = new Thread(()->{
try {
for (int i = 0; i < 10; i++) {
synchronized (locker1) {
locker1.wait();
}
System.out.print("A");
synchronized (locker2) { // 要清楚唤醒的是哪个线程
locker2.notify();
}
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
});
Thread t2 = new Thread(()->{
try {
for (int i = 0; i < 10; i++) {
synchronized (locker2) {
locker2.wait();
}
System.out.print("B");
synchronized (locker3) { // 要清楚唤醒的是哪个线程
locker3.notify();
}
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
});
Thread t3 = new Thread(()->{
try {
for (int i = 0; i < 10; i++) {
synchronized (locker3) {
locker3.wait();
}
System.out.println("C");
synchronized (locker1) { // 要清楚唤醒的是哪个线程
locker1.notify();
}
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
});
t1.start();
t2.start();
t3.start();
// 确保t1先执行到了wait
Thread.sleep(1000);
synchronized (locker1) { // notify一定要和synchronized配合使用
locker1.notify();
}
}
}
单例模式
单例模式属于设计模式的一种，是指一个进程中，一个类只能实例化一个对象，即单个实例。那怎么去实现一个进程中只能有一个对象呢？直接把构造方法改为private即可，这样在外部就不能创建实例了。
单例模式中，最常见的就是饿汉模式与懒汉模式。
饿汉模式
饿汉模式，主要体现在"饿"字上，因为其是迫不及待的去创建类的实例。
代码演示：
// 饿汉模式
class SingleTon {
// 迫不及待的创建实例
private static SingleTon singleTon = new SingleTon();
public static SingleTon getInstance() {
return singleTon;
}
// 单例模式的构造方法一定是private修饰的
private SingleTon() {
}
}这里创建类的实例是通过创建一个静态的成员变量来实现的，而静态的成员变量是类在加载时，就会被创建，即JVM中有这个类存在的痕迹的话，那么这个实例就会存在。 因此，以"饿"得名。
我们也可以去检查这个饿汉模式是否创建成功，主要检查是否是单例模式。
public class Test {
public static void main(String[] args) {
// SingleTon s = new SingleTon(); // error
SingleTon s1 = SingleTon.getInstance();
SingleTon s2 = SingleTon.getInstance();
System.out.println(s1 == s2); // true
}
}从上面的程序运行的结果，可以得知：一个进程中不能实例化多个对象，符合单例模式的特征。
懒汉模式
懒汉模式，主要体现在"懒"字上，只有当迫不得已时，才去创建实例。
代码演示：
// 懒汉模式
class SingleTonLazy {
// 迫不得已才创建实例
private static SingleTonLazy singleTonLazy = null;
public static SingleTonLazy getInstance() {
if (singleTonLazy == null) {
singleTonLazy = new SingleTonLazy(); // 一定要把对象保留下来
}
return singleTonLazy;
}
// 单例模式的构造方法一定是私有的
private SingleTonLazy() {
}
}懒汉模式只有当外部调用getInstance方法时，才会去创建实例，否则就不会创建实例。
同样也可以去测试这个懒汉模式是否创建成功。
public class Test {
public static void main(String[] args) {
// SingleTonLazy s = new SingleTonLazy(); // error
SingleTonLazy s1 = SingleTonLazy.getInstance();
SingleTonLazy s2 = SingleTonLazy.getInstance();
System.out.println(s1 == s2); // true
}
}
上面的懒汉模式在单线程下使用没问题，但是在多线程下使用，便会出现线程安全问题。（饿汉模式之所没有线程安全问题，是因为饿汉模式只是进行return的"读"操作，而不是和懒汉模式一样，有"写"操作）
因为懒汉模式的创建线程虽然只是一个赋值代码，也就是对应一条CPU指令，但是有了 if 语句之后，两者就不算是原子的了。
例如，当线程1去实例化一个对象时，执行到 if 语句，但偏偏此时操作系统将其从CPU上踢下去了，然后线程2就也去CPU上执行了实例化对象的操作，和线程1一样只是执行到 if 语句，也被赶下去了，接着 线程1执行了赋值语句成功的创建了一个对象，然后线程2又被调度到CPU上了，也执行了创建对象的赋值语句。
上面就会导致两个问题：
1、 这里new了两次，即创建了两次对象破坏了单例模式的初衷。
2、后一次new的对象会覆盖前面的对象，可以会对程序的数据造成影响，最终导致程序崩溃。
这里有小伙伴可能会疑惑：为什么线程1创建了对象之后，线程2还会去创建对象呢？因为线程1创建完成之后，线程2已经执行到了 if 语句之中，其认为还没有创建对象。
因此，我们得对上述代码进行加锁操作。
// 懒汉模式
class SingleTonLazy {
// 迫不得已才创建实例
private static SingleTonLazy singleTonLazy = null;
private static Object locker = new Object();
public static SingleTonLazy getInstance() {
synchronized (locker) {
if (singleTonLazy == null) {
singleTonLazy = new SingleTonLazy(); // 一定要把对象保留下来
}
}
return singleTonLazy;
}
// 单例模式的构造方法一定是私有的
private SingleTonLazy() {
}
}加锁操作确实可以实现线程安全，但是它也会造成程序的性能下降，因为当对象的实例被创建出来后，别的线程再去调用这个方法时，就会进行加锁操作，而加锁对于最终的结果来说没影响，也就是加锁加了个寂寞，这就是在浪费时间了。因此，也就导致了性能下降了。
我们的解决方法是在锁的最外层再加上一个 if 语句去判断，这样即使有了实例之后，别的线程再尝试去创建实例时，就会直接return，而不会再去进行加锁操作了，这样性能就提升了不少。
public static SingleTonLazy getInstance() {
if (singleTonLazy == null) {
synchronized (locker) {
if (singleTonLazy == null) {
singleTonLazy = new SingleTonLazy(); // 一定要把对象保留下来
}
}
}
return singleTonLazy;
}指令重排序
上面的懒汉模式代码，还是有点问题，这个问题和指令重排序有关。
概念：指令重排序是指在不影响代码的执行逻辑的基础上，编译器对要执行的代码其底层对应的计算机指令进行了优化处理，会使其与原来的执行顺序不一致。
懒汉模式的指令重排序体现在 赋值语句。我们先来学习一下，这个赋值语句，其底层对应的逻辑：1、向内存申请了一块空间；2、在这块空间内构造对象（初始化成员变量等）3、将这块空间的首地址给到引用变量。如果将上述三个操作类比到我们日常生活的话，那就是1、买房子；2、装修；3、拿到钥匙。
指令重排序可能会使这个1、2、3的顺序打乱，变成1、3、2。虽然这个在日常生活中，即使打乱之后，我们也是不会直接入住的，因为还没有装修，但是计算机可不一样，它是一个铁憨憨，他只知道执行工作，因此当它执行了1、3之后，也就是拿到了这个对象的引用之后，如果此时操作系统将其从CPU上踢下去了，让别的线程来执行相关方法的话，这个操作就不亚于在毛坯房中直接拎包入住的行为了。这可能直接就把程序给搞崩溃了。因此，我们不能让指令重排序的行为发生，这里就需要用到 volatile 关键字了。这个关键字既可以避免 内存可见性的问题，也可以避免指令重排序的问题。
private static volatile SingleTonLazy singleTonLazy = null;好啦！本期 初始JavaEE篇——多线程（4）：wait、notify，饿汉模式，懒汉模式，指令重排序 的学习之旅 就到此结束啦！我们下一期再一起学习吧！
