Java学习笔记6-线程安全之可见性

Java学习笔记6-线程安全之可见性

线程安全问题：当多个线程先后操作同一个变量进行读写时，由于其他线程的覆盖操作、CPU缓存、指令重排序等原因，导致数据出现偏差，这就会产生线程安全问题。

测试代码

import java.util.concurrent.TimeUnit;

/**
 * @Author: Wenx
 * @Description:
 * @Date: Created in 2019/11/13 20:19
 * @Modified By：
 */
public class DemoTest {
    private static boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        // 创建线程循环进行累加
        new Thread(new Runnable() {
            @Override
            public void run() {
                int i = 0;
                while (DemoTest.flag) {
                    i++;
                }
                System.out.println("结果为：" + i);
            }
        }).start();

        TimeUnit.SECONDS.sleep(2);
        // 设置flag为false，使线程结束while循环，输出结果
        DemoTest.flag = false;
        System.out.println("flag设置为false");
    }
}

测试结果：线程没有结束，惊不惊喜，意不意外？这就是线程不安全。

初步分析线程不安全是由于2个线程（main线程、thread线程）中demoTest.flag共享变量不同步导致，共享变量如果至少有一个访问是写的，那么对同一个变量的两次访问（读或写）是冲突的；

可能因为CPU缓存，但CPU缓存可能导致非常短的时间内不一致，while了2秒应该不是这个问题；

还有种可能就是指令重排序，由于class文件在运行时为提高JVM性能会进行 JIT（即时编译器）优化，将编译后的汇编指令运行时进行重排序或等效替换，while (demoTest.flag) 因长时间为true可能被优化为如下：

boolean f = DemoTest.flag;
if (f) {
    while (true) {
        i++;
    }
}

从而导致线程没有结束,，为证明是这个原因在运行时VM options可以设置关闭JIT优化：

-Djava.compiler=NONE

怎么样？循环是不是结束了，并且显示了结果！当然我们正式环境是不可能关闭JIT优化的，那么我们可以有其他JDK提供的相应解决办法。

解决办法：

volatile：volatile关键字可以保持可见性、避免重排序的问题。

1. 禁止缓存，突破内存壁障；
2. 对volatile变量相关的指令不做重排序

volatile测试代码

import java.util.concurrent.TimeUnit;

/**
 * @Author: Wenx
 * @Description:
 * @Date: Created in 2019/11/13 20:19
 * @Modified By：
 */
public class DemoTest {
    private static volatile boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        // 创建线程循环进行累加
        new Thread(new Runnable() {
            @Override
            public void run() {
                int i = 0;
                while (DemoTest.flag) {
                    i++;
                }
                System.out.println("结果为：" + i);
            }
        }).start();

        TimeUnit.SECONDS.sleep(2);
        // 设置flag为false，使线程结束while循环，输出结果
        DemoTest.flag = false;
        System.out.println("flag设置为false");
    }
}

看看是不是好使了！

synchronized：同步关键字也可以保持可见性，使代码同步。

synchronized测试代码

import java.util.concurrent.TimeUnit;

/**
 * @Author: Wenx
 * @Description:
 * @Date: Created in 2019/11/13 20:19
 * @Modified By：
 */
public class DemoTest {
    private static boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        // 创建线程循环进行累加
        new Thread(new Runnable() {
            @Override
            public void run() {
                int i = 0;
                while (DemoTest.flag) {
                    synchronized (this) {
                        i++;
                    }
                }
                System.out.println("结果为：" + i);
            }
        }).start();

        TimeUnit.SECONDS.sleep(2);
        // 设置flag为false，使线程结束while循环，输出结果
        DemoTest.flag = false;
        System.out.println("flag设置为false");
    }
}

是不是也可以了~