网站建设 图纸网,wordpress 5.1.1漏洞,wordpress 点击特效,响应式网站模板怎么做摄影分享~~ 文章目录 volatile关键字volatile能保证内存可见性 wait和notifywaitnotifynotifyAllwait和sleep的区别小练习 多线程案例单例模式饿汉模式懒汉模式 volatile关键字
volatile能保证内存可见性
import java.util.Scanner;class MyCounter {public int flag 0;
}p… 摄影分享~~ 文章目录 volatile关键字volatile能保证内存可见性 wait和notifywaitnotifynotifyAllwait和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
举个列子 t1t2两个线程希望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还没有执行waitt2已经执行了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供12使用 创建locker2供23使用 线程3locker2.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的方式来创建一个Singletonprivate 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);}
}
