volatile关键字的相关学习记录

1：volatile是什么？

Volatile是java虚拟机提供的一种轻量级的同步机制，具有 三大特性，分别是：保证可见性、不保证原子性、禁止指令重排

可见性：

概念：每一个线程都有自己的工作内存，线程不能直接操作主内存的值，必须把主内存的数据拷贝回工作内存进行更改后，刷新回主内存，并及时通知其他线程

import java.util.concurrent.TimeUnit;

public class test {
    public static void main(String[] args) {
        MyData myData = new MyData();

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            }catch (Exception e){

            }
            myData.addTo60();

            System.out.println(Thread.currentThread().getName() + " update value to 60 :" + myData.number);
        },"AAA").start();

        while (myData.number == 0){

        }

        System.out.println(Thread.currentThread().getName() + " get value mydata.number :" + myData.number);
    }
}

class MyData{

    /**
     * 当加了volatile这个关键字的时候，由于其中一个线程修改完毕 立即通知，那么另一个线程就会收到值被修改，则在上述循环方法中将会跳出 并结束
     *
     * 如果不加，则其中一个线程将不会收到值被修改的情况，导致while循环将一直存在
     */
    volatile int number=0;

    public void addTo60(){
        this.number=60;

    }
}

不保证原子性：

代码：

import java.util.concurrent.TimeUnit;

public class test {
    public static void main(String[] args) {
        //验证volatile不保证原子性的问题
        MyData myData = new MyData();
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 1; j <= 1000; j++) {
                    myData.addPlusPlus();
                }

            },String.valueOf(i)).start();
        }

        //等待执行完成，
        while (Thread.activeCount()> 2){
            Thread.yield();
        }

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

class MyData{

    volatile int number=0;

    public void addPlusPlus(){
        this.number++;

    }
}

打印结果将不可预测

处理非原子性问题

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

public class test {
    public static void main(String[] args) {
        //验证volate不保证原子性的问题
        MyData myData = new MyData();
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 1; j <= 1000; j++) {
                    myData.addPlusPlus();
                    myData.addAtomic();
                }

            },String.valueOf(i)).start();
        }

        //等待执行完成，
        while (Thread.activeCount()> 2){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + " number:" + myData.number);
        System.out.println(Thread.currentThread().getName() + " atomic:" + myData.atomicInteger);

    }
}

class MyData{

    int number=0;

    public void addPlusPlus(){
        number++;

    }

    AtomicInteger atomicInteger =  new AtomicInteger();
    public void addAtomic(){
        atomicInteger.getAndIncrement();

    }
}

　

禁止指令重排：

编译器和操作系统会对指令进行优化和重排序，通过volatile可以禁止重排序，主要是在多线程环境下，变量的顺序可能发生变化 从而导致结果不可预测的问题。

代码：单例模式使用volatile方法

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

public class test {

    //双端检索 + volatile 禁止指令重排序
    private static volatile test  t  = null;
    private test(){
        System.out.println(Thread.currentThread().getName() + " test-构造方法！");
    }
    private static  test getTestInstince(){
        if(t == null){
            synchronized (test.class){
                if(t == null){
                    t = new test();

                }
            }
        }
        return t;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                System.out.println(test.getTestInstince());
            },Thread.currentThread().getName() + String.valueOf(i)).start();
        }

    }

}