摄影分享~~
文章目录
- volatile关键字
- volatile能保证内存可见性
- wait和notify
- wait
- notify
- notifyAll
- wait和sleep的区别
- 小练习
- 多线程案例
- 单例模式
- 饿汉模式
- 懒汉模式
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线程已经执行完了。
以上情况，就叫做内存可见性问题
这里使用汇编来理解，大概分为两步操作：
- load，把内存中flag的值，读到寄存器中。
- cmp，把寄存器中的值，和0进行比较。根据比较结果，决定下一步往哪个地方执行（条件跳转指令）
上述循环循环体为空，循环执行速度极快。循环执行很多次，在t2真正修改之前，load得到的结果都是一样的。另一方面，load操作和cmp操作相比，速度慢的多得多。由于load执行速度太慢（相比于cmp），再加上反复load到的结果都是一样的，JVM就做出了一个大胆的决定：不再真正的重复load，判定没有人修改flag值（但实际上是有人在修改的，t2在修改），直接就读取一次就好。（编译器优化的一种方式）
内存可见性问题：一个线程针对一个变量进行读取操作，同时另一个线程针对这个变量进行修改。此时读到的值，并不一定是修改之后的值。（jvm/编译器在多线程环境下优化时残生了误判）
此时，我们就需要手动干预了。我们可以给flag这个变量加上volatile关键字。告诉编译器，这个变量是“易变”的，需要每一次都重新读取这个变量的内容。
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.
这个异常，很多带有阻塞功能的方法都带，这些方法都是可以被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后");
}
}
这里会出现非法的锁状态异常。锁的状态一般是被加锁的状态，被解锁的状态。
为什么会出现这个异常呢？和wait的操作有关：
wait的操作：
- 先释放锁
- 进行阻塞等待
- 收到通知后，重新尝试获取锁，并且在获取锁后，继续往下执行。
上述代码没有锁就想要释放锁，所以出现了非法的锁状态异常。
因此，wait操作要搭配synchronized来使用。
notify
wait和notify一般搭配使用。notify方法用来唤醒wait等待的线程, 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
多线程案例
单例模式
单例模式是设计模式的一种。
单例模式能保证某个类在程序中只存在唯一一份的实例，而不会创建出多个实例。
单例模式具体的实现方式分为“饿汉”和“懒汉”。
饿汉模式
类加载的同时，创建实例。
类对象在一个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);
}
}
- 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);
}
}
在多线程中调用instance，饿汉模式是线程不安全的。
那么如何保证懒汉模式线程安全呢？
**加锁。**线程安全的本质问题，就是读，比较，写这三个操作不是原子的。所以我们可以加锁来解决线程安全问题。
但是，加锁操作就导致每次调用getInstance都需要花一定的开销。而我们的加锁只针对new对象之前，所以我们就可以判断一下对象是否创建，再去决定加锁。
如果对象创建了，就不加锁。如果对象没有创建，就加锁。
上述代码还存在一个问题，即内存可见性问题：
假如调用getInstance的线程有很多，此时代码就有可能被优化（第一次读内存，后续读的是寄存器/cache）
除此之外，可能还会涉及到指令重排序。
上述代码中，分为三个步骤：
- 申请内存空间
- 调用构造方法，把这个内存空间初始化成一个对象
- 把内存空间的地址赋值给instance引用
而编译器的指令重排序操作就会调整代码执行顺序，123可能会变成132.(单线程中没有影响)
我们可以给代码中加上volatile。
volatile有两个功能：
- 解决内存可见性
- 禁止指令重排序。
以下为懒汉模式的单例模式的完整代码：
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);
}
}
