首先先介绍三个性质
可见性
可见性代表主内存中变量更新，线程中可以及时获得最新的值。
下面例子证明了线程中可见性的问题
由于发现多次执行都要到主内存中取变量，所以会将变量缓存到线程的工作内存，这样当其他线程更新该变量的时候，该线程无法得知，导致该线程会无限的运行下去。
public class test1 {
private static int flag = 1;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(()->{
while (flag == 1){
}
},"t1");
t1.start();
Thread.sleep(1000);
flag = 2;
}
}
当我们在这个死循环中加入一个synchronized关键字的话就会将更新
猜测：synchronized会使更新当前线程的工作内存
public class test1 {
private static int flag = 1;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(()->{
while (flag == 1){
synchronized ("1"){
}
}
},"t1");
t1.start();
Thread.sleep(1000);
flag = 2;
}
}
原子性
即多线程中指令执行会出现交错，导致数据读取错误。
比如i++的操作就可以在字节码的层面可以被看成以下操作
9 getstatic #9 <com zhf test3 test2.i : i> 获得i
12 iconst_1 将1压入操作数栈
13 isub 将两数相减
14 putstatic #9 <com zhf test3 test2.i : i> 将i变量存储
</com></com>
然后在多线程的情况下，会出现以下程序出现非0的结果。
public class test2 {
private static int i;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(()->{
for (int j = 0; j < 400; j++) {
i++;
}
});
Thread t2 = new Thread(()->{
for (int j = 0; j < 400; j++) {
i--;
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}
}
@Slf4j
public class test3 {
private Thread monitor;
private volatile boolean flag = false;
public static void main(String[] args) {
test3 test3 = new test3();
test3.monitor = new Thread(()->{
while (true){
Thread thread = Thread.currentThread();
if (test3.flag){
log.debug("正在执行后续");
break;
}
try {
log.debug("线程正在执行");
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
// 当进程在睡眠过程中被Interrupte()打断此时isInterrupted()为false
// 从而当异常被抓住后会继续执行
// 所以要调用下面方法继续将isInterrupted()置为true
// thread.interrupt();
}
}
});
test3.start();
try {
Thread.sleep(5500);
} catch (InterruptedException e) {
e.printStackTrace();
}
test3.stop();
}
public void stop(){
flag = true;
monitor.interrupt();
}
public void start(){
monitor.start();
}
}
具体实现，最常见的就是单例模式。
首先是饿汉模式，这里的多线程安全是由JVM保证的，对象是在类加载的加载阶段创建的。
class SingtonHungry{
private static Object object = new Object();
// 饿汉模式
public synchronized Object getObject() {
return object;
}
}
其次就是饿汉模式，最常见的不过就是下面的进行多线程安全的方案。文章后面会对其进行优化。
class SingtonLazy{
private Object object;
// 懒汉模式
// 由于这样的话不管有没有创建出对象都要加锁然后才能取对象，性能太差
public synchronized Object getObject() {
if (object == null){
object = new Object();
return object;
}
return object;
}
}
有序性
JVM会对指令进行重排序，其和CPU的流水线操作类似，当需要流水线操作的时候，需要进行优化的时候，就会对CPU指令进行重排序优化。
当操作的顺序变了之后，就会出现问题。可能会导致条件的提前触发等等。
Volatile使用
使用域： Volatile只能在类的静态成员变量或者成员变量上。
volatile标识符能够让线程强制去读主存的该变量的值，保证了线程变量的可见性。
volatile标识符能够让线程去顺序执行该变量的操作，保证了执行变量的语句的有序性
- 在读取该变量时，会为其添加读屏障。在该读屏障之后的代码不会放在读屏障之前执行。
- 在写该变量时，会为其添加写屏障。在该写屏障之前的代码不会在屏障之后执行。
所以在volatile的修饰下，能够保证变量的可见性和有序性，但并不能保证其的原子性。
class SingtonLazy{
// 加上volatile的主要目的就是防止在synchronized内的代码指令重排，正常是先构造好对象然后赋对象地址
// 导致object会被首先赋予了地址，导致其不为null，然而构造方法还没有开始构造
// 被其他的线程拿走会出现使用出错。
private static volatile Object object;
// 懒汉模式
public static Object getObject() {
if (object != null){
return object;
}else{
// 这里可能出现这里的线程还没有为其进行声明对象，但已经由线程进入了等待锁
// 所以需要在这里来一个为空判断。
synchronized (SingtonLazy.class){
// 这里可能会出现指令重排，所以要加上volatile
if(object == null){
object = new Object();
}
return object;
}
}
}
}
实现单例的另外一个方式
public class Singleton {
// 当使用到ObjectHolder才会进行到这个静态内部类的加载，同时才会创建该类
// 也是属于懒汉式
private static class ObjectHolder{
static final Singleton singleton = new Singleton();
}
}
synchronized补充
首先在synchronized代码块中，它会保证代码块中的可见性，原子性和有序性。
有序性仅仅是表现在synchronized的执行后最后的结果都是一样的，并不会阻止JVM在其内部进行代码的重排序。就比如上个例子来说，在synchronized代码块中最后代码的执行结果都是一样的，但可能由于其优化，导致其他线程出错。
Original: https://www.cnblogs.com/duizhangz/p/16243965.html
Author: 大队长11
Title: Volatile的学习
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/621794/
转载文章受原作者版权保护。转载请注明原作者出处！