【JavaEE初阶】多线程（三）volatile wait notify关键字单例模式-Toy模板网

这篇具有很好参考价值的文章主要介绍了【JavaEE初阶】多线程（三）volatile wait notify关键字单例模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

摄影分享~~

volatile关键字

volatile能保证内存可见性

import java.util.Scanner;

class MyCounter {
    public int flag = 0;
}

public class ThreadDemo14 {
    public static void main(String[] args) {
        MyCounter myCounter = new MyCounter();

        Thread t1 = new Thread(() -> {
            while (myCounter.flag == 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("t1 循环结束");
        });

        Thread t2 = new Thread(() -> {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入一个整数: ");
            myCounter.flag = scanner.nextInt();
        });

        t1.start();
        t2.start();
    }
}

以上代码运行的结果可能是输入1后，t1这个线程并没有结束。而是一直在while中循环。而t2线程已经执行完了。
以上情况，就叫做内存可见性问题
【JavaEE初阶】多线程（三）volatile wait notify关键字单例模式
这里使用汇编来理解，大概分为两步操作：

load，把内存中flag的值，读到寄存器中。
cmp，把寄存器中的值，和0进行比较。根据比较结果，决定下一步往哪个地方执行（条件跳转指令）

上述循环循环体为空，循环执行速度极快。循环执行很多次，在t2真正修改之前，load得到的结果都是一样的。另一方面，load操作和cmp操作相比，速度慢的多得多。由于load执行速度太慢（相比于cmp），再加上反复load到的结果都是一样的，JVM就做出了一个大胆的决定：不再真正的重复load，判定没有人修改flag值（但实际上是有人在修改的，t2在修改），直接就读取一次就好。（编译器优化的一种方式）
内存可见性问题：一个线程针对一个变量进行读取操作，同时另一个线程针对这个变量进行修改。此时读到的值，并不一定是修改之后的值。（jvm/编译器在多线程环境下优化时残生了误判）
此时，我们就需要手动干预了。我们可以给flag这个变量加上volatile关键字。告诉编译器，这个变量是“易变”的，需要每一次都重新读取这个变量的内容。
【JavaEE初阶】多线程（三）volatile wait notify关键字单例模式
volatile不保证原子性，原子性是由synchronized来保证的。

wait和notify

举个列子：
t1，t2两个线程，希望t1先执行任务，任务执行快结束了让t2来干，就可以让t2先wait（阻塞，主动放弃cpu）。等t1任务执行快结束了，在通过notify通知t2，把t2唤醒，让t2开始执行任务。
上述场景中，使用join和sleep可以吗？
使用join，必须要t1彻底执行完，t2才能执行。如果希望t1执行一半任务然后让t2执行，join无法完成。
使用sleep，必须制定一个休眠时间，但是t1执行任务的时间是难以估计的。
使用wait和notify可以解决上述问题。

wait

wait进行阻塞，某个线程调用wait方法，就会进入阻塞，此时就处于WAITING.
【JavaEE初阶】多线程（三）volatile wait notify关键字单例模式

这个异常，很多带有阻塞功能的方法都带，这些方法都是可以被interrupt方法通过以上异常唤醒。
我们再来看一个代码：

public class ThreadDemo17 {
        public static void main(String[] args) throws InterruptedException {
            Thread t = new Thread(() -> {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("执行完毕！");
            });

            t.start();
            System.out.println("wait前");
            t.wait();
            System.out.println("wait后");
        }
}

【JavaEE初阶】多线程（三）volatile wait notify关键字单例模式
这里会出现非法的锁状态异常。锁的状态一般是被加锁的状态，被解锁的状态。
为什么会出现这个异常呢？和wait的操作有关：

wait的操作：

先释放锁

进行阻塞等待

收到通知后，重新尝试获取锁，并且在获取锁后，继续往下执行。

上述代码没有锁就想要释放锁，所以出现了非法的锁状态异常。
因此，wait操作要搭配synchronized来使用。
【JavaEE初阶】多线程（三）volatile wait notify关键字单例模式

notify

wait和notify一般搭配使用。notify方法用来唤醒wait等待的线程, wait能够释放锁, 使线程等待, 而notify唤醒线程后能够获取锁, 然后使线程继续执行。
【JavaEE初阶】多线程（三）volatile wait notify关键字单例模式
如果上述代码中，t1还没有执行wait，t2已经执行了notify，那么此时的声明就是没有用的。t2执行notify后，t1执行wait后会一直阻塞等待。
注意上述代码在t2唤醒t1之后，t1和t2之间的执行是随机的，也是就标号3和标号4的地方的顺序是不确定的。

方法	效果
wait();	无参数，一直等直到notify唤醒
wait(时间参数);	指定最长等待时间

notifyAll

notify方法只是唤醒某一个等待线程. 使用notifyAll方法可以一次唤醒所有的等待线程.
一般情况下，使用notify。因为全部唤醒会导致线程之间抢占式执行。不一定安全。

wait和sleep的区别

相同点：

都可以使线程暂停一段时间来控制线程之间的执行顺序.
wait可以设置一个最长等待时间, 和sleep一样都可以提前唤醒.

不同点：

wait是Object类中的一个方法, sleep是Thread类中的一个方法.
wait必须在synchronized修饰的代码块或方法中使用, sleep方法可以在任何位置使用.
wait被调用后当前线程进入BLOCK状态并释放锁，并可以通过notify和notifyAll方法进行唤醒；sleep被调用后当前线程进入TIMED_WAITING状态，不涉及锁相关的操作.
使用sleep只能指定一个固定的休眠时间, 线程中执行操作的执行时间是无法确定的; 而使用wait在指定操作位置就可以唤醒线程.
sleep和wait都可以被提前唤醒, interruppt唤醒sleep, 是会报异常的, 这种方式是一个非正常的执行逻辑; 而noitify唤醒wait是正常的业务执行逻辑, 不会有任何异常.

小练习

有三个线程, 分别只能打印 A, B, C. 控制三个线程固定按照 ABC 的顺序来打印.

public class ThreadDemo18 {
    // 有三个线程, 分别只能打印 A, B, C. 控制三个线程固定按照 ABC 的顺序来打印.
    public static void main(String[] args) throws InterruptedException {
        Object locker1 = new Object();
        Object locker2 = new Object();
        Thread t1 = new Thread(()->{
            System.out.println("A");
            synchronized (locker1) {
                locker1.notify();
            }
        });
        Thread t2 = new Thread(()->{
            synchronized (locker1) {
                try {
                    locker1.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

            }
            System.out.println("B");
            synchronized (locker2) {
                    locker2.notify();
            }
        });
        Thread t3 = new Thread(()->{
            synchronized (locker2) {
                try {
                    locker2.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("C");
        });
        t2.start();
        t3.start();
        Thread.sleep(100);
        t1.start();
    }
}

创建locker1，供1，2使用
创建locker2，供2，3使用
线程3，locker2.wait()
线程2, locker1.wait()唤醒后执行locker2.notify
线程1执行自己的任务，执行完后locker.notify
【JavaEE初阶】多线程（三）volatile wait notify关键字单例模式

多线程案例

单例模式

单例模式是设计模式的一种。
单例模式能保证某个类在程序中只存在唯一一份的实例，而不会创建出多个实例。
单例模式具体的实现方式分为“饿汉”和“懒汉”。

饿汉模式

类加载的同时，创建实例。
类对象在一个java进程中，只有一份。因此类对象内部的类属性也是唯一的。
在类加载阶段，就把实例创建出来了。

//饿汉模式的单例模式的实现
//保证Singleton这个类只能创建出一个实例
class Singleton{
    //在此处，先将实例创建出来
    private static Singleton instance = new Singleton();

    public static Singleton getInstance() {
        return instance;
    }
    //为了避免Singleton类不小心被多复制出来
    //把构造方法设为private，在类外，无法通过new的方式来创建一个Singleton
    private Singleton(){

    }
}
public class ThreadDemo19 {
    public static void main(String[] args) {
        Singleton s = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        //Singleton s3 = new Singleton();
        System.out.println(s == s2);
    }
}

【JavaEE初阶】多线程（三）volatile wait notify关键字单例模式

static保证这个实例唯一
static保证这个实例被创建出来。

懒汉模式

class SingletonLazy{
    private static SingletonLazy instance = null;


    public static SingletonLazy getIsntance() {
        if(instance == null){
            instance = new SingletonLazy();
        }
        return instance;
    }
}
public class ThreadDemo20 {
        public static void main(String[] args) {
            SingletonLazy s = SingletonLazy.getIsntance();
            SingletonLazy s2 = SingletonLazy.getIsntance();
            System.out.println(s == s2);
        }
}

【JavaEE初阶】多线程（三）volatile wait notify关键字单例模式

在多线程中调用instance，饿汉模式是线程不安全的。
【JavaEE初阶】多线程（三）volatile wait notify关键字单例模式
那么如何保证懒汉模式线程安全呢？
**加锁。**线程安全的本质问题，就是读，比较，写这三个操作不是原子的。所以我们可以加锁来解决线程安全问题。

但是，加锁操作就导致每次调用getInstance都需要花一定的开销。而我们的加锁只针对new对象之前，所以我们就可以判断一下对象是否创建，再去决定加锁。
如果对象创建了，就不加锁。如果对象没有创建，就加锁。
【JavaEE初阶】多线程（三）volatile wait notify关键字单例模式
上述代码还存在一个问题，即内存可见性问题：
假如调用getInstance的线程有很多，此时代码就有可能被优化（第一次读内存，后续读的是寄存器/cache）
除此之外，可能还会涉及到指令重排序。
【JavaEE初阶】多线程（三）volatile wait notify关键字单例模式
上述代码中，分为三个步骤：

申请内存空间
调用构造方法，把这个内存空间初始化成一个对象
把内存空间的地址赋值给instance引用

而编译器的指令重排序操作就会调整代码执行顺序，123可能会变成132.(单线程中没有影响)
我们可以给代码中加上volatile。
volatile有两个功能：

解决内存可见性
禁止指令重排序。

以下为懒汉模式的单例模式的完整代码：文章来源地址https://www.toymoban.com/news/detail-425019.html

class SingletonLazy{
    private volatile static SingletonLazy instance = null;


    public static SingletonLazy getInstance() {
        if(instance ==null){
            synchronized (SingletonLazy.class){
                if(instance == null){
                    instance = new SingletonLazy();
                }
            }
        }  

        return instance;
    }
}
public class ThreadDemo20 {
        public static void main(String[] args) {
            SingletonLazy s = SingletonLazy.getInstance();
            SingletonLazy s2 = SingletonLazy.getInstance();
            System.out.println(s == s2);
        }
}