Java从语言层面实现可见性的实现方式

synchronized

synchronized能够实现互斥锁（同步），能够保证只有一个线程在操作锁里面代码，synchronized除了能够实现原子性，还可以实现可见性。

JMM关于synchronized的两条规定：

线程解锁前，必须把共享变量的最新值刷新到主内存中；
线程加锁时，将清空当前线程工作内存中共享变量的值，从而当前线程使用共享变量时需要从主内存中重新读取最新的值（注意：加锁和解锁需要是同一把锁）；

也就是说线程解锁前对共享变量的修改在下次加锁时对其他线程可见。

线程执行互斥代码的过程如下：

这里有一段简单的代码示例：

package dgb.test.concurrent;

public class SynchronizedDemo {
	//共享变量
    private static boolean ready = false;
    private static int result = 0;
    private static int number = 1;

    public static void write(){
    	ready = true;	      				//1.1
    	number = 2;		                    //1.2
    }

    public static void read(){
    	if(ready){						    //2.1
    		result = number*3;	 			//2.2
    	}
    	System.out.println("result为" + result);
    }

    private static class ReadWriteThread extends Thread {
    	private boolean flag;
    	public ReadWriteThread(boolean flag){
    		this.flag = flag;
    	}
        @Override
        public void run() {
        	if(flag){
        		write();
        	}else{
        		read();
        	}
        }
    }

    public static void main(String[] args)  {
        new ReadWriteThread(true).start();
        /*try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }*/
        new ReadWriteThread(false).start();
    }
}

这个代码会有多种情况，因为1.1和1.2，2.1和2.2都有可能发生重排序。如果执行顺序为1.1-2.1-2.2-1.2，即第一个线程在执行了1.1的代码后（且对ready的修改能够及时刷新至主内存），让出了CPU的资源，那么第二个线程在执行2.1的时候，此时ready为true，则会执行2.2的代码，此时number并不是3，而是1，所以result输出的值反而是3。

所以一个解决方式就是在write()和read()方法上加上synchronized关键字。

这里共享变量不可见的原因主要有三个：

线程的交叉执行
重排序结合线程交叉执行
共享变量未及时更新

而synchronized就相当于加了一把锁，让锁内部的代码保持原子性，可以防止线程的交叉执行。而由于锁内部的代码保持了原子性，这时候无论锁内部的代码是否发生重排序都不会对结果造成影响。而结合“JMM关于synchronized的两条规定”，synchronized是可以保证共享变量及时更新的，synchronized也就解决了上述造成共享变量不可见的三个问题。

volatile

在Java中使用了一些特殊的操作或者关键字来申明、告诉虚拟机，在这个地方，要小心了，不能随意变动优化目标指令。其中就包含volatile关键字。

volatile是通过加入内存屏障和禁止重排序优化来实现可见性的：

对volatile变量写操作时，会在写操作后加入一条store屏障指令，将本地内存中的共享变量刷新到主内存；
对volatile变量读操作时，会在读操作前加入一条load屏障指令，从主内存中读取共享变量；

简单点水就是，volatile变量在每次被线程访问时，都强迫从主内存中重读该变量的值，而当该变量发生变化时，又会强迫线程将最新的值刷新到主内存。这样任何时刻不同的线程总能看到该变量的最新值。

但是要注意的是volatile能够保证volatile变量的可见性，但是不能保证volatile变量复合操作的原子性。

比如在下面的例子中，volatile并不能保证i++是原子操作：

package dgb.test.concurrent;

/**
 * @author Dongguabai
 * @date 2018/9/1 23:04
 */
public class VolatileTest {

    static volatile int i;

    public static class AddTask implements Runnable{

        @Override
        public void run() {
            for (int j = 0;j<10000;j++){
                i++;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int j = 0; j <1000 ; j++) {
            Thread thread1 = new Thread(new AddTask());
            Thread thread2= new Thread(new AddTask());
            thread1.start();
            thread2.start();
            thread1.join();
            thread2.join();
            System.out.println(i);
            i = 0;
        }
    }
}

执行结果：

一般使用volatile需要同时满足：

对变量的写操作不依赖其当前值（但是Boolean变量是可以适用的）；
该变量没有包含在具有其他变量的不变式中；

synchronized和 volatile比较

volatile不需要加锁，比 synchronized更轻量级,不会阻塞线程；
从内存可见性角度将，volatile读相当于加锁，volatile写相当于解锁;
synchronized既能保证可见性，又能保证原子性，而 volatile只能保证可见性，无法保证原子性；

并发编程学习之线程可见性

相关概念

计算机多核并发内存架构

JMM

指令重排序

可见性

共享变量可见性实现的原理

Java从语言层面实现可见性的实现方式

synchronized

volatile

synchronized和 volatile比较

猜你喜欢