一、可见性

1、实例讲解

4、使用synchronized同步代码段强制实现原子性和可见性

一、可见性

1、实例讲解

先看这样一段代码：

public class Test {

	static boolean a = true;
	
	public static void main(String[] args) {
		a = false;					//对a执行写操作
		System.out.println(a); 		//对a执行读操作
	}
}

我们在单线程中，对a执行了写操作，并且读取到了最新写的值，也就是说，单线程中对a的写操作时可见的。

那么我们再开启一个线程：

public class Test {

	static boolean a = true;
	
	public static void main(String[] args) throws InterruptedException {
		new Thread(()-> {
			while(a) {}	//死循环
		}).start();
		
		Thread.sleep(1000);	//为了保证不会影响，停一秒再写		
		a = false;					//对a执行写操作
		System.out.println(a); 		//对a执行读操作
	}
}

可以看到，虽然a仍然打印出为false，但是程序没有结束，就说明在我们新开启的线程中a的值始终为true，他才可以一直执行while循环。换句话说，我们的主线程对a的写操作对于新开的线程的读操作来说是不可见的。

为什么这么长时间了，新开线程中的a还是true呢？那是因为新线程中一直在执行循环，使得线程没有机会去拿到主存中a的最新值，而是一直读取缓存中a的值。

那么，我们让循环沉睡一会儿，给他去读最新值的机会：

public class Test {

	static boolean a = true;
	
	public static void main(String[] args) throws InterruptedException {
		new Thread(()-> {
			while(a) {
				try {
					Thread.sleep(1);	//睡1ms，给线程去读新值的机会
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}	//死循环
		}).start();
		
		Thread.sleep(1000);	//为了保证不会影响，停一秒再写		
		a = false;					//对a执行写操作
		System.out.println(a); 		//对a执行读操作
	}
}

可以看到，程序很快就结束了，说明新线程已经读到了a的新值为false，结束了循环。

2、如何理解Java线程中的不可见性？

简单来说：线程1读，线程2写，而线程1读不到线程2写的值，这就是不可见性。

3、那么如何实现可见性呢？

就需要用到volatile关键字了：

public class Test {

	static volatile boolean a = true;
	
	public static void main(String[] args) throws InterruptedException {
		new Thread(()-> {
			while(a) {}	//死循环
		}).start();
		
		Thread.sleep(1000);	//为了保证不会影响，停一秒再写		
		a = false;					//对a执行写操作
		System.out.println(a); 		//对a执行读操作
	}
}

二、原子性

保证可见性可以保证一个线程写之后，另一个线程可以读到。
那假如一个进程既读取变量，又依赖读到的变量进行写操作呢？我们来看下面的例子：

1、实例讲解

用两个线程分别执行10000次a++的操作，按道理来说，a的结果应该会增加20000

public class Test {

	static int a = 0;
	
	public static void main(String[] args) throws InterruptedException {
		
		for(int i=0; i<10000; i++) {
			new Thread(()-> {
				a++;
			}).start();
			new Thread(()-> {
				a++;
			}).start();
		}		
		
		Thread.sleep(1000);	//为了保证不会影响，停一秒再写		
		System.out.println(a); 		//对a执行读操作
	}
}

可以看到，结果和我们的预期对不上，那我们加上volatile关键字试一下：

结果还是对不上，这是为什么呢？

这就要探究a++的本质了

2、a++的本质

a++可以拆分为三个操作：1、读取a； 2、a+1； 3、将加之后的值赋给a

有可能会出现这种情况：
1、当a=0时，线程1读取a值，线程2也读取a值；
2、线程1将它读到的a值+1，此时为1，线程2也将它读到的a值+1，此时为1；
3、线程1将1这个值刷入主存，此时主存中的a=1；线程2也将1这个值刷入主存，此时为1

这显然是不对的，两个线程各执行一次a++，a的值应该+2才对。刚刚我们得到的值为19998，可能就是有两个线程在其他线程+之前读取到了a值。

那加上volatile关键字之后呢？

volatile关键字只能保证可见性，即一个线程写过之后，另一个线程能够立马读到。而假如线程2操作在线程1操作写之前就已经读了，那还是没办法改变这个情况。这两个线程都需要读取主存的值，并且每个线程都依赖自己读取的值进行写操作。这就需要保证原子性了。

3、使用Atomicxxxx保证原子性：

public class Test {

	static AtomicInteger a = new AtomicInteger(0);
	
	public static void main(String[] args) throws InterruptedException {
		
		for(int i=0; i<10000; i++) {
			new Thread(()-> {
				a.getAndAdd(1);
			}).start();
			new Thread(()-> {
				a.getAndAdd(1);
			}).start();
		}		
		
		Thread.sleep(1000);	//为了保证不会影响，停一秒再写		
		System.out.println(a); 		//对a执行读操作
	}
}

可以看到，a++的操作改成了getAndAdd()，读和写是一起执行的，这就不会在读值之后写值之前被其他线程插一杠子。

需要注意的一点是，原子性和可见性并不是相互独立的，保证原子性的前提是保证可见性，那为什么我们没有再用volatile修饰a来保证可见性呢？这就需要去看看AtomicInteger的源码了：

其实它的内部也使用了volatile关键字。

4、使用synchronized同步代码段强制实现原子性和可见性

除了Atomic，也可以使用synchronized同步代码段强制实现原子性。

public class Test {

	static AtomicInteger a = new AtomicInteger(0);
	static int b = 0;
	
	public static void main(String[] args) throws InterruptedException {
		
		for(int i=0; i<10000; i++) {
			new Thread(()-> {
//				a.getAndAdd(1);
				synchronized(Test.class) {
					b++;
				}
			}).start();
			new Thread(()-> {
//				a.getAndAdd(1);
				synchronized(Test.class) {
					b++;
				}
			}).start();
		}		
		
		Thread.sleep(1000);	//为了保证不会影响，停一秒再写		
//		System.out.println(a); 		//对a执行读操作
		System.out.println(b); 		//对b执行读操作
	}
}

相比较Atomic，synchronized就更加重量级了。

另外：volatile不具有传染性，用volatile修饰的对象的内部属性不具有可见性，反之用volatile修饰的内部属性也不能保证所在对象的可见性。

参考：【java】并发之可见性与原子性_哔哩哔哩_bilibili

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/125030.html