找往期文章包括但不限于本期文章中不懂的知识点:
个人主页:我要学编程(ಥ_ಥ)-CSDN博客
所属专栏:JavaEE
目录
wait、notify 方法
多线程练习
单例模式
饿汉模式
懒汉模式
指令重排序
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,饿汉模式,懒汉模式,指令重排序 的学习之旅 就到此结束啦!我们下一期再一起学习吧!