多线程之 volatile 关键字随笔

最新推荐文章于 2024-10-11 17:32:18 发布

爱上猫de鱼

最新推荐文章于 2024-10-11 17:32:18 发布

阅读量185

点赞数

分类专栏：线程

本文链接：https://blog.csdn.net/boy_chen93/article/details/103064032

版权

线程专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1、volatile的作用

学习多线程始终跳不过“volatile”这个关键字，最大的作用是：多线程的共享可见性。什么意思，下面画个图就明白了：

每个线程都有自己的私有数据栈，他们取值都是从自己的数据栈中取，但是我们修改这个值是在公共堆栈中进行的，所以我们希望每个线程都从公共堆栈中取值，那么就把这个值设定为volatile。

如下，代码演示：

package com.chenjianwen.test03;

/**
 * @Description: <br>
 * @Date: Created in 2019/11/14 <br>
 * @Author: chenjianwen
 */
public class VolatilTest extends Thread{

    boolean flag = true;
    int i = 0;

    @Override
    public void run() {
        while(flag){
            i++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        VolatilTest vt = new VolatilTest();
        vt.start();
        Thread.sleep(1000);
        vt.flag = false;
        System.out.println("i=" + vt.i);
    }
}

上面代码步骤及预想结果如下：

vt.start(); 开启线程，执行run()方法，由于flag是true，i值一直自增。

Thread.sleep(1000); 主线程睡1秒。

vt.flag = false; 将flag设为false，那么while(flag){}循环结束。循环结束，线程结束

System.out.println("i=" + vt.i); 获取到i的值。

按道理线程结束，循环应该也结束了，但结果是：

该循环一直在运行，也就是说该线程读到的flag一直是true。事实是我们在主线程中已经将flag的值更改为false了，也就是说公共堆栈中的flag值是false的，但是该线程读的一直是自己私有数据栈中的flag的值，是true。

那么此时，我们需要将该值设为volatile，其作用是：强制从公共堆栈中获取变量的值，而不是从线程私有堆栈中获取变量的值。

这样运行结果如下，就不会死机了。

2、volatile的缺陷

volatile虽然保证了实例变量在多个线程之间的可见性，但是并不具备同步性（也就是原子性），如下测试：

package com.chenjianwen.test03;

/**
 * @Description: <br>
 * @Date: Created in 2019/11/14 <br>
 * @Author: chenjianwen
 */
public class AtomVolatile extends Thread{

    volatile public static int count;

    private static void addCount(){
        for(int i = 0; i < 100; i++){
            count++;
        }
        System.out.println("count = " + count);
    }

    @Override
    public void run() {
        addCount();
    }

    public static void main(String[] args) {
        AtomVolatile[] av = new AtomVolatile[100];
        for(int i = 0; i < 100; i++){
            av[i] = new AtomVolatile();
        }
        for(int i = 0; i< 100; i++){
            av[i].start();
        }
    }
}

上述main方法的含义是：100个AtomVolatile的线程去加载addCount()方法，改变count的值。我们预期的运行结果是，一个线程加载该方法，count增加100，然后另一个线程再让其加100，如此循环。但结果却是如下：

实际结果并不是如预期一般100的加，那我们分析一下，线程体run()方法干了什么事：

1）从内存中读取count的值

2）计算并增加count的值

3）再将count的值存到内存中

此时，当一个线程在第2步计算count的值时，另一个线程也在计算并且已经增加count的值了，那么就会有如上的脏数据。解决的方法有两个：

2.1 使用synchronized关键字

    private synchronized static void addCount(){
        for(int i = 0; i < 100; i++){
            count++;
        }
        System.out.println("count = " + count);
    }

执行结果如下，如预期一般，整百整百的增加：

2.2 使用原子类进行操作

package com.chenjianwen.test03;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Description: <br>
 * @Date: Created in 2019/11/14 <br>
 * @Author: chenjianwen
 */
public class AtomVolatile extends Thread{

    public static AtomicInteger count = new AtomicInteger(0);

    private static void addCount(){
        for(int i = 0; i < 100; i++){
            count.incrementAndGet();
        }
        System.out.println("count = " + count);
    }

    @Override
    public void run() {
        addCount();
    }

    public static void main(String[] args) {
        AtomVolatile[] av = new AtomVolatile[100];
        for(int i = 0; i < 100; i++){
            av[i] = new AtomVolatile();
        }
        for(int i = 0; i< 100; i++){
            av[i].start();
        }
    }
}

主要的代码如下这一部分:

运行结果如下:

如预期一样，整百整百的增加。。。

但是原子类也并非完全同步的，换言之，也并非完全安全，如下代码所示：

package com.chenjianwen.test05;

import java.util.concurrent.atomic.AtomicLong;

/**
 * @Description: <br>
 * @Date: Created in 2019/11/14 <br>
 * @Author: chenjianwen
 */
public class RunMain {

    public static void main(String[] args) throws InterruptedException {
        MyService ms = new MyService();
        MyThread[] arr = new MyThread[5];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = new MyThread(ms);
        }
        for (int i = 0; i < arr.length; i++) {
            arr[i].start();
        }

        Thread.sleep(1000);
        System.out.println(ms.ref.get());
    }
}

class MyService{
    public AtomicLong ref = new AtomicLong();

    public void addNum() {
        System.out.println(Thread.currentThread().getName() + "加了100后的值=" + ref.addAndGet(100));
        ref.addAndGet(1);
    }
}

class MyThread extends Thread {

    private MyService myService;

    public MyThread(MyService myService) {
        super();
        this.myService = myService;
    }

    @Override
    public void run() {
        this.myService.addNum();
    }
}

预期执行结果应该是：100，201，302，403，504，505。但实际却是:

出现这样的原因是：addAndGet()方法是原子的，但是方法和方法之间的调用却不是原子的。

要解决这个问题必须使用同步块synchronized，如下所示：

执行结果如下：

符合我们预期的结果。

2.3 synchronized代码块具有volatile同步的功能

关键字synchronized可以使多个线程访问同一个资源具有同步性，而且它还具有将线程工作内存中的私有变量与公共内存中的变量同步的功能。如下代码演示：

package com.chenjianwen.test05;


/**
 * @Description: <br>
 * @Date: Created in 2019/11/14 <br>
 * @Author: chenjianwen
 */
public class RunMain01 {

    public static void main(String[] args) throws InterruptedException {
        Service s = new Service();
        new AThread(s).start();
        Thread.sleep(1000);
        new BThread(s).start();
        System.out.println("已经发起了停止的命令！");
    }
}

class Service{

    private boolean isContinue = true;

    public void runMethod(){
        while(isContinue){

        }
        System.out.println("停下来了！");
    }

    public void stopMethod(){
        this.isContinue = false;
    }
}

class AThread extends Thread{

    private Service service;

    public AThread(Service service){
        super();
        this.service = service;
    }

    @Override
    public void run() {
        this.service.runMethod();
    }
}

class BThread extends Thread{

    private Service service;

    public BThread(Service service){
        super();
        this.service = service;
    }

    @Override
    public void run() {
        this.service.stopMethod();
    }
}

上面开启了a和b两个线程，a线程开启循环，b线程关闭循环。如果关闭了，那么肯定打印了"停下来了！"这句话。但结果如下：