traceid java多线程 java多线程volatile

文章目录

• volatile介绍
• volatile 不适用的场景

volatile介绍

volatile是一种同步机制, 比synchronized 或者Lock 更轻量级, 因为使用volatile 并不会发生上下文切换等开销很大的行为. 仅仅是把值刷入主内存中, 和从主内存中读取值.

如果一个变量被修饰成volatile , 那么JVM就这个了这个变量可能会被并发修改.

由于volatile 开销小, 因此相应的并发能力也小, 虽然volatile 是用来同步保证线程安全性的, 但是volatile不能做到synchronized 那样的原子保护, volatile仅仅在很有限的场景下才能发挥作用 .

volatile 不适用的场景

不适用于a++的情况

如下的代码演示了 volatile 不适用于a++的场景.
起了两个线程, 对a进行++操作 ,并且 a用 volatile 修饰.
并且用AtomicInteger 统计实际的执行次数

package com.thread.jmm;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 类名称:IncorrectVolatile
 * 类描述:volatile 不适用的场景
 *
 * @author: 
 * 创建时间:2020/9/6 10:08
 * Version 1.0
 */
public class IncorrectVolatile implements Runnable {
    volatile int a = 0;

    //原子类, 统计执行了多少次
    AtomicInteger atomicInteger = new AtomicInteger();

    public static void main(String[] args) throws InterruptedException {
        IncorrectVolatile runnable = new IncorrectVolatile();
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);

        thread1.start();
        thread2.start();

        //主线程等待子线程执行完毕
        thread1.join();
        thread2.join();

        System.out.println("a++的结果: "+runnable.a);
        System.out.println("运行a++的次数 : "+runnable.atomicInteger.get());
    }

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            a++;
            atomicInteger.incrementAndGet();
        }
    }
}

运行结果如下图, 说明了 a++的结果少了,还是出现了线程不安全的情况, 因此volatile 不适用于 a++的场景.

在如下的这篇文章中, 说明过a++变少的原因:

在线程1 执行了加1操作的时候, 还没把最新的值赋值给i , cpu调度就把执行权给了线程2 , 导致原本此时应该是i是2的,但是却获取到的是1的值. 这样就导致了加的值变小了.

如下图所示 a++ , 其实是三步.

这也说明了volatile 只能保证可见性, 但并不能保证原子性. 读取a, 给a+1 , 再把+1后的值刷回内存中, 这三步是原子性的. 如果中间被打断了, 那么就会导致a++的结果变少.

把上面的代码中, 修改如下 , 给a++操作加上synchronized 锁, 保证其原子性 , 即可解决a++变少的问题.

package com.thread.jmm;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 类名称:IncorrectVolatile
 * 类描述:volatile 不适用的场景
 *
 * @author: 
 * 创建时间:2020/9/6 10:08
 * Version 1.0
 */
public class IncorrectVolatile implements Runnable {
    int a = 0;

    //原子类, 统计执行了多少次
    AtomicInteger atomicInteger = new AtomicInteger();
    private  final  Object lock =  new Object();

    public static void main(String[] args) throws InterruptedException {
        IncorrectVolatile runnable = new IncorrectVolatile();
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);

        thread1.start();
        thread2.start();

        //主线程等待子线程执行完毕
        thread1.join();
        thread2.join();

        System.out.println("a++的结果: "+runnable.a);
        System.out.println("运行a++的次数 : "+runnable.atomicInteger.get());
    }
    @Override
    public void run() {

        synchronized (lock){
            for (int i = 0; i < 10000; i++) {
                a++;
                atomicInteger.incrementAndGet();
            }
        }
    }
}

运行结果如图