volatile关键字

请你谈谈对volatile关键字的理解

volatile是Java虚拟机的轻量级的同步机制,具有三个特性:

1. 保证可见性
2. 不保证原子性
3. 禁止指令重排

1.可见性:当一个线程修改了主线程的值,其他的线程可以立即通知其他线程值被修改了

2.原子性:一个线程正在做某个操作时,中途不能被加塞/分割,需要整体执行的完整,要么同时成功,要么同时失败

3.指令重排:处理器在进行重排序之前要考虑最终的执行结果和代码顺序结果的一致性,进行指令重排的操作,必须要

考虑数据的依赖性.由于在多线程的环境中,数据交互执行,由于编译器指令优化重排序的存在,多个线程中使用的数据

的一致性是无法确定的,而volatile通过插入内存屏障,禁止内存屏障前后的指令执行进行重排序优化.

可见性代码:

class MyData{

    int number = 0; //没有加入volatile关键字

    public void change(){
        this.number = 60;
    }
}

public static void seeValueByVolatile(){
        MyData myData = new MyData();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "	"+ myData.number);

            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myData.change();
            System.out.println(Thread.currentThread().getName() + "	"+ myData.number);
        },"可见性测试").start();

 两个线程的数据并不同步

class MyData{

    volatile int number = 0; //添加volatile关键字

    public void change(){
        this.number = 60;
    }
}

public static void seeValueByVolatile(){
        MyData myData = new MyData();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "	"+ myData.number);

            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myData.change();
            System.out.println(Thread.currentThread().getName() + "	"+ myData.number);
        },"可见性测试").start();



        while (myData.number == 0){

        }
        System.out.println(Thread.currentThread().getName() + "	" + myData.number);
    }

 两个线程的数据同步一致

 原子性代码:

 开启20个线程执行number++1000次,最终的结果应该是20000

class MyData{

    volatile int number = 0;

    public void change(){
        this.number = 60;
    }

    //number++ 被拆分为3个指令,执行getfield获取原始的值,执行iadd进行加1操作,执行putfield写把累加后的值写回到主内存
    public void addPlus(){
        number++;
    }

}

 public static void atomicByVolatile(){
        MyData myData = new MyData();

        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                for (int j = 1; j <= 1000; j++) {
                    myData.addPlus();//出现了写丢失的情况
                  
                }
            },String.valueOf(i)).start();
        }

        while (Thread.activeCount() > 2){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + "	" + myData.number);
        System.out.println(Thread.currentThread().getName() + "Atomic Number:" + "	" + myData.atomicInteger);
    }

 但由于线程争抢,写丢失的情况存在,导致数值的丢失

 解决方法:使用原子引用类

class MyData{

    volatile int number = 0;

    public void change(){
        this.number = 60;
    }

    //number++ 被拆分为3个指令,执行getfield获取原始的值,执行iadd进行加1操作,执行putfield写把累加后的值写回到主内存
    public void addPlus(){
        number++;
    }

    AtomicInteger atomicInteger =  new AtomicInteger();
    //不使用sync的方式来实现原子性,使用JUC下的AtomicInteger
    public void addPlusAtomic(){
        atomicInteger.getAndIncrement();
    }
}

public static void atomicByVolatile(){
        MyData myData = new MyData();

        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                for (int j = 1; j <= 1000; j++) {
                    //myData.addPlus();//出现了写丢失的情况
                    myData.addPlusAtomic();
                }
            },String.valueOf(i)).start();
        }

        while (Thread.activeCount() > 2){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + "	" + myData.number);
        System.out.println(Thread.currentThread().getName() + "Atomic Number:" + "	" + myData.atomicInteger);
    }

 结果正确

 案例完整代码:

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class VolatileDemo{
    public static void main(String[] args) {

        seeValueByVolatile();
        atomicByVolatile();

    }

    public static void atomicByVolatile(){
        MyData myData = new MyData();

        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                for (int j = 1; j <= 1000; j++) {
                    myData.addPlus();//出现了写丢失的情况
                    myData.addPlusAtomic();
                }
            },String.valueOf(i)).start();
        }

        while (Thread.activeCount() > 2){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + "	" + myData.number);
        System.out.println(Thread.currentThread().getName() + "Atomic Number:" + "	" + myData.atomicInteger);
    }

    public static void seeValueByVolatile(){
        MyData myData = new MyData();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "	"+ myData.number);

            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myData.change();
            System.out.println(Thread.currentThread().getName() + "	"+ myData.number);
        },"可见性测试").start();



        while (myData.number == 0){

        }
        System.out.println(Thread.currentThread().getName() + "	" + myData.number);
    }
}


class MyData{

    volatile int number = 0;

    public void change(){
        this.number = 60;
    }

    //number++ 被拆分为3个指令,执行getfield获取原始的值,执行iadd进行加1操作,执行putfield写把累加后的值写回到主内存
    public void addPlus(){
        number++;
    }

    AtomicInteger atomicInteger =  new AtomicInteger();
    //不使用sync的方式来实现原子性,使用JUC下的AtomicInteger
    public void addPlusAtomic(){
        atomicInteger.getAndIncrement();
    }
}