分类

volatile

JAVA学习网 2020-11-23 00:02:02

JMM（java内存模型）

  • JMM屏蔽了底层不同计算机的区别，描述了Java程序中线程共享变量的访问规则，以及在jvm中将变量存储到内存和从内存中读取变量这样的底层细节。

  • JMM有以下规定：

    • 所有的共享变量都存储与主内存中，这里所说的变量指的是实例变量和类变量，不包含局部变量，因为局部变量是线程私有的，因此不存在竞争问题。

    • 每一个线程还存在自己的工作内存，线程的工作内存，保留了被线程使用的变量的工作副本。

    • 线程对变量的所有操作（读和写）都必须在工作内存中完成，而不能直接读写主内存中的变量。

    • 不同线程之间也不能直接访问对方工作内存中的变量，线程间变量的值传递需要通过主内存中转来完成。

多线程下变量的不可见性：

public class test7 {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();
        while (true) {
            if (t.isFlag()) {
                System.out.println("停不下来了"); // 不会执行到这里
            }
        }
    }
}
class MyThread extends Thread {
    private boolean flag = false;
    // private volatile boolean flag = false;
    @Override
    public void run() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flag = true;
        System.out.println("flag被修改了");
    }

    public boolean isFlag() {
        return flag;
    }
}

原因：

  • 子线程t从主内存读取到数据放入其对应的工作内存
  • 将flag的值更改为true，但flag的值还没有写回主内存
  • 此时main方法读取到了flag的值为false
  • 当子线程t将flag的值写回主内存后，主线程没有再去读取主内存中的值，所以while(true)读取到的值一直是false。

volatile 的特性

  • volite 可以实现并发下共享变量的可见性；

  • volite 不保证原子性；

  • volite 可以防止指令重排序的操作。

    使用原子类来保证原子性：

    public AtomicInteger()： 初始化一个默认值为0的原子型Integer 
public AtomicInteger(int initialValue)： 初始化一个指定值的原子型
Integer int get(): 获取值 
int getAndIncrement(): 以原子方式将当前值加1，注意，这里返回的是自增前的值。 
int incrementAndGet(): 以原子方式将当前值加1，注意，这里返回的是自增后的值。 
int addAndGet(int data): 以原子方式将输入的数值与实例中的值（AtomicInteger里的 value）相加，并返回结果。 
int getAndSet(int value): 以原子方式设置为newValue的值，并返回旧值

    private static AtomicInteger atomicInteger = new AtomicInteger();
Runnable r = () -> {
     for (int i = 0; i < 100; i++) {
           atomicInteger.incrementAndGet();
     }
};

    有时为了提高性能，编译器和处理器常常会对既定的代码执行顺序进行指令重排序。重排序可以提高处理的速度。

volatile写读建立的happens-before关系

happens-before ：前一个操作的结果可以被后续的操作获取。

happens-before规则：

  1. 程序顺序规则（单线程规则）

    同一个线程中前面的所有写操作对后面的操作可见

  2. 锁规则（Synchronized,Lock等）

    如果线程1解锁了monitor a，接着线程2锁定了a，那么，线程1解锁a之前的写操作都对线程2可见（线程

    1和线程2可以是同一个线程）

  3. volatile变量规则：

    如果线程1写入了volatile变量v（临界资源），接着线程2读取了v，那么，线程1写入v及之前的写操作都

    对线程2可见（线程1和线程2可以是同一个线程）

  4. 传递性：

    A h-b B ， B h-b C 那么可以得到 A h-b C

  5. join()规则：

    线程t1写入的所有变量，在任意其它线程t2调用t1.join()，或者t1.isAlive() 成功返回后，都对t2可见。

  6. start()规则：

    假定线程A在执行过程中，通过执行ThreadB.start()来启动线程B，那么线程A对共享变量的修改在接下来

    线程B开始执行前对线程B可见。注意：线程B启动之后，线程A在对变量修改线程B未必可见。

public class VisibilityHP { 
    int a = 1; 
    int b = 2; 
    private void write() { 
        a = 3;
        b = a; 
    }
    private void read() { 
        System.out.println("b=" + b + ";a=" + a); 
    }
    public static void main(String[] args) { 
        while (true) { 
            VisibilityHP test = new VisibilityHP(); 
            new Thread(new Runnable() { 
                @Override 
                public void run() { 
                    test.write(); 
                } 
            }).start(); 
            new Thread(new Runnable() { 
                @Override 
                public void run() { 
                    test.read(); 
                } 
            }).start(); 
        } 
    } 
}

没给b加volatile,那么有可能出现a=1 , b = 3 。因为a虽然被修改了，但是其他线程不可见，而b恰好其他线程可见，造成了b=3 , a=1。

如果使用volatile修饰long和double，那么其读写都是原子操作

volatile在双重检查加锁的单例中的应用

饿汉式（静态常量）

public class Singleton01 {
    private static final Singleton01 Intance = new Singleton01();

    private Singleton01() {}

    public static Singleton01 getIntance() {
        return Intance;
    }
}

饿汉式（静态代码块）

public class Singleton02 {
    private final static Singleton02 Intance;

    static {
        Intance = new Singleton02();
    }

    private Singleton02() {}

    public static Singleton02 getInstance() {
        return Intance;
    }
}

懒汉式（线程安全，性能差）

public class Singleton03 {
    private static Singleton03 Instance;

    private Singleton03() {}

    public static synchronized Singleton03 getInstance() {
        if (Instance == null) {
            Instance = new Singleton03();
        }
        return Instance;
    }
}

懒汉式（volatile双重检查模式,推荐）

public class Singleton04 {
    private static volatile Singleton04 Instance = null;

    private Singleton04() {}

    public static Singleton04 getInstance() {
        if (Instance == null) {
            synchronized (Singleton04.class) {
                if (Instance == null) {
                    //创建对象的过程是非原子操作
                    Instance = new Singleton04();
                }
            }
        }
        return Instance;
    }
}

此处加上volatile 的作用：

① 禁止指令重排序。

创建对象的过程要经过以下几个步骤s：

a. 分配内存空间

b. 调用构造器，初始化实例

c. 返回地址给引用

原因：由于创建对象是一个非原子操作，编译器可能会重排序，即只是在内存中开辟一片存储空间后直接返回内存的引用。而下一个线程在判断 instance 时就不为null 了，但此时该线程只是拿到了没有初始化完成的对象，该线程可能会继续拿着这个没有初始化的对象继续进行操作，容易触发“NPE 异常”。

② 保证可见性

静态内部类单例方式

public class Singleton05 {
    private Singleton05() {}
    private static class SingletonInstance {
        private static final Singleton05 INSTANCE = new Singleton05();
    }
    
    public static Singleton05 getInstance() {
        return SingletonInstance.INSTANCE;
    }
}
  1. 静态内部类只有在调用时才会被加载，jvm在底层会保证只有一个线程去初始化实例，下一个线程获取实例时就直接返回。
  2. 相比于双重检查，静态内部类的代码更简洁。但基于volatile的双重检查有一个额外的优势：除了可以对静态字段实现延迟加载初始化外，还可以对实例字段实现延迟初始化。

volatile使用场景

  1. volatile适合做多线程中的纯赋值操作：如果一个共享变量自始至终只被各个线程赋值，而没有其他操作，那么可以用volatile来代替synchronized，因为赋值操作本身是原子性的，而volatile又保证了可见性，所以足以保证线程安全。

  2. volatile可以作为刷新之前变量的触发器，可以将某个变量设置为volatile修饰，其他线程一旦发现该变量修改的值后，触发获取到该变量之前的操作都将是最新可见的。

    public class test8 {
    int a = 1;
    int b = 2;
    int c = 3;
    volatile boolean flag = false;
    public void write() {
        a = 100;
        b = 200;
        c = 300;
        flag = true;
    }
    public void read() {
        while (flag) {
            System.out.println("a=" + a + " " + "b=" +  b + " " + "c=" + c);
            break;
        }
    }

    public static void main(String[] args) {
        test8 test8 = new test8();
        new Thread(() -> {
            test8.write();
        }).start();
        new Thread(() -> {
            test8.read();
        }).start();
    }
}

volatile 和synchronized的区别

  1. volatile只能修饰实例变量和类变量，而synchronized可以修饰方法，以及代码块。
  2. volatile保证数据的可见性，但是不保证原子性，不保证线程安全。
  3. volatile可以禁止指令重排序，解决单例双重检查对象初始化代码执行乱序问题。
  4. volatile可以看做轻量版synchronized，volatile不保证原子性，但是如果对一个共享变量只进行纯赋值操作，而没有其他操作，那么可以使用volatile来代替synchronized，因为赋值本身是有原子性的，而volatile又保证了可见性，所以就保证了线程安全。
阅读(2427) 评论(0)