Java volatile的认识

最新推荐文章于 2024-10-12 17:55:45 发布

发_疯了

最新推荐文章于 2024-10-12 17:55:45 发布

阅读量127

点赞数 1

分类专栏： Java 文章标签： java volatile

本文链接：https://blog.csdn.net/qq_37376948/article/details/116377750

版权

Java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

在并发编程中，我们通常会被提问这几个个问题：原子性问题，可见性问题，有序性问题，互斥性问题。我们先看具体看一下这四个的概念：

原子性
即一个操作或者多个操作要么全部执行并且执行的过程不会被任何因素打断，要么就全部不执行。
比如从账户A向账户B转1000元，那么包括2个操作：从账户A减去1000元，往账户B加上1000元，如果银行系统不稳定的原因，导致执行了减1000元迟迟没有加B账户的1000，这时有人在B账户取钱，这个时候这个人要等到钱到账才能继续取钱，要么1000元回滚后才能取钱。
可见性
指当多个线程操作同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改后的新值。
有序性
即程序执行的顺序按照代码的先后顺序执行。一般来说，虚拟机为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的，这就是指令重排序，这个跟有序性相反。
指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性。也就是说，要想并发程序正确地执行，必须要保证原子性、可见性、有序性、互斥性。只要有一个没有被保证，就有可能并发不安全了。
互斥性
资源不能同时被多个线程操作，一个时间内只能运行一个线程操作。

volatile关键字
1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
2）禁止进行指令重排序。

public class TestVolatile {

    public static void main(String[] args){ //这个线程是用来读取flag的值的
        ThreadDemo threadDemo = new ThreadDemo();
        Thread thread = new Thread(threadDemo);
        thread.start();
        while (true){

            if (threadDemo.flag){
                System.out.println("主线程读取到的flag = " + threadDemo.flag);
                break;
            }}

    }
}

class ThreadDemo implements Runnable{ //这个线程是用来修改flag的值的
//    public volatile boolean flag = false;
    public boolean flag = false;
    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flag = true;
        System.out.println("ThreadDemo线程修改后的flag = " + flag);
    }
}

结果：该程序并没有结束，也就是死循环。说明主线程读取到的flag还是false，可是另一个线程明明将flag改为true了，而且打印出来了，这是什么原因呢？因为main线程读取到threadDemo.flag还是旧的，不是最新值，这就是内存可见性问题。在这里插入图片描述

改成这样之后，可以正常结束了

从上面知道volatile关键字保证了操作的可见性，但是volatile不能保证对变量操作是原子性和互斥的
看看这个例子：

public class ThreadTestInt {
    public static void main(String[] args) {
        Sub sub = new Sub();
        for (int i = 0; i < 100; i++) {
            new Thread(sub).start();
        }
    }
}
class Sub implements Runnable{
   private volatile int i = 1;
    @Override
    public void run() {
        System.out.print(i++);
        System.out.print(" ");
    }
}

// volatile  "1 3 2 44 43 42 41 40 39 38 37 36 35 34 32 33 31 30 29 28 27 26 25 24 23 22 21 20 19 18 45 17 16 15 48 49 50 51 52 53 14 13 58 12 11 10 9 8 6 7 5 4 67 66 63 68 62 98 69 97 70 96 71 95 72 94 73 74 93 75 76 92 91 90 77 78 89 88 79 87 80 81 86 82 83 85 84 60 64 64 59 57 56 55 54 47 46 99 61 65";

出现了两个64，说明并发不安全的。自增操作是不具备原子性的，它包括读取变量的原始值、进行加1操作、写入工作内存。那么就是说自增操作的三个子操作可能会被分割执行。
假设开始i=63时，线程1对变量进行自增操作，线程1先读取了变量i的原始值63，然后线程1被阻塞了；然后线程2对i变量进行自增操作，线程2也去读取变量i的原始值63，由于线程1只是对变量i进行读取操作，而没有对变量进行修改操作，所以线程2会直接去主存读取i的值63，然后进行加1操作，并把64写入工作内存，最后写入主存。然后线程1接着进行加1操作，由于已经读取过了i的值，注意此时在线程1的工作内存中i的值仍然为63，所以线程1对i进行加1操作后i的值为64，然后将64写入工作内存，最后写入主存。那么两个线程分别进行了一次自增操作后，i只增加了1。
在这里插入图片描述

//  1 3 2 93 95 59 94 58 57 56 54 55 53 52 51 50 49 48 47 46 45 44 43 42 40 41 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 5 7 6 4 61 64 62 63 65 66 67 68 69 70 71 72 73 75 74 76 77 78 79 80 81 82 83 85 84 86 87 88 89 90 91 92 96 97 98 99 100 60

采用AtomicInteger可以达到并发安全的效果。