一、共享变量在线程间的可见性
可见性:一个线程对共享变量值的修改,能够及时的被其他线程看到。
共享变量:如果一个变量在多个线程的工作内存中都存在副本,那么这个变量就是这几个线程的共享变量。
上面的工作内存其实是java内存模型抽象出来的概念,下面简要介绍一下java内存模型(JMM)。
java内存模型(java memory model)描述了java程序中各种变量(线程共享变量)的访问规则,以及在JVM中将变量存储到内存和从内存中读取出变量这样的底层细节。
- 所以的变量都存储在主内存中
- 每个线程都有自己独立的工作内存,里面保存该线程使用到的变量的副本(主内存该变量的一份拷贝)。如下图:
两条规定:
- 线程对共享变量的所有操作都必须在自己的工作内存中进行,不能直接从主内存中读写。
- 不同线程之间无法直接访问其他线程工作内存中的变量,线程间值的传递需要通过主内存来完成。
共享变量可见性实现的原理:
线程1对共享变量的修改要想被线程2及时看到,必须要经过如下几个步骤:
- 将工作内存1中更新过的共享变量更新到主内存中
- 将主内存中最新的共享变量的值更新到工作内存2中
二、synchronized实现可见性
JMM关于synchronized的两条规定:
- 线程解锁前,必须把共享变量的最新值刷新到主内存中
- 线程加锁时,将清空工作内存中共享变量的值,从而使用共享变量时需要从主内存中重新读取最新的值。(加锁和解锁需要是同一把锁)
线程解锁前对共享变量的修改在下次加锁前对其他线程可见。
线程执行互斥代码的过程:
- 获得互斥锁
- 情况工作内存
- 从主内存拷贝变量的最新副本到工作内存
- 执行代码
- 将更改后的共享变量的值刷新到主内存
- 释放互斥锁
下面通过一段代码来讲解synchronized关键字,在这之前还需要明晰一些概念。
重排序:代码书写的顺序与实际执行的顺序不同,指令重排序是编译器或处理器为了提高程序性能而做的优化。
as-if-serial:无论如何重排序,程序执行的结果应该与代码顺序执行的结果一致。
重排序不会给单线程带来内存可见性问题,多线程中程序交错执行时,重排序可能会造成内存可见性的问题。
导致共享变量在线程间不可见的原因: synchronized解决方案:
- 线程的交叉执行 ------> 原子性
- 重排序结合线程交叉执行 ------> 原子性
- 共享变量更新后的值没有在工作内存与主内存间及时更新 ------> 可见性
下面的代码主要是通过给线程类不同的状态值使其执行不同的方法。两个线程分别执行不同的方法,其中会涉及到指令的重排序。可能会产生不同的结果。
package memoryVisual;
public class SynchronizedDemo {
//共享变量
private boolean ready = false;
private int result = 0;
private int number = 1;
//写操作
public void write(){
ready = true; //1.1
number = 2; //1.2
}
//读操作
public void read(){
if(ready){ //2.1
result = number*3; //2.2
}
System.out.println("result的值为:" + result);
}
//内部线程类
private class ReadWriteThread extends Thread {
//根据构造方法中传入的flag参数,确定线程执行读操作还是写操作
private boolean flag;
public ReadWriteThread(boolean flag){
this.flag = flag;
}
@Override
public void run() {
if(flag){
//构造方法中传入true,执行写操作
write();
}else{
//构造方法中传入false,执行读操作
read();
}
}
}
public static void main(String[] args) {
SynchronizedDemo synDemo = new SynchronizedDemo();
//启动线程执行写操作
synDemo .new ReadWriteThread(true).start();
// try {
// Thread.sleep(1000);
// } catch (InterruptedException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
//启动线程执行读操作
synDemo.new ReadWriteThread(false).start();
}
}
运行结果包括:1.result的值为:0 2.result的值为:6
若结果为0,则可能的运行顺序为1.2---2.1---2.2---1.1.
若结果为6,则有很多种运行顺序,各位自行分析。
需要注意的一点是,若给write和read方法加上synchronized关键字,则一定是按照先write再read的顺序执行的,即1.1,1.2一定在2.1,2.2之前执行,则结果一定为“result的值为:6”。但1.1和1.2的执行顺序可能会发生重排。
三、volatile实现可见性
volatile关键字:
- 能够保证volatile变量的可见性
- 不能保证volatile变量复合操作的可见性
- 不能保证volatile变量复合操作的原子性
对于第三点,例如代码private int number = 0;number++;就不是原子操作。因为这句代码可分为三步:1.读取number的值 2.将number的值加1 3.写入最新的number的值。
而通过synchronized(this){
number++;
}
就可以实现原子操作。
但是即使将number的初始化语句改为private volatile int number = 0;仍然无法保证原子性。
tips:synchronized及volatile关键字都可以保证可见性,但只要synchronized可以保证原子性。
volatile关键字如何实现内存可见性:通俗的讲,volatile关键字每次被线程访问时,都强迫从主内存中重读该变量的值,而当该变量发生变化时,又会强迫线程将最新的值刷新到主内存。这样任何时刻,不同的线程总能看到该变量的最新值。
线程写volatile变量的过程:
- 改变线程工作内存中volatile变量副本的值
- 将改变后的副本的值从工作内存刷新到主内存
线程读volatile变量的过程:
- 从主内存中读取volatile变量的最新值到线程的工作内存中
- 从工作内存中读取volatile变量的副本
下面通过一段代码说明volatile不能保证原子性:
package memoryVisual;
public class VolatileDemo {
private volatile int number = 0;
public int getNumber(){
return this.number;
}
public void increase(){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
this.number++;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
final VolatileDemo volDemo = new VolatileDemo();
for(int i = 0 ; i < 500 ; i++){
new Thread(new Runnable() {
@Override
public void run() {
volDemo.increase();
}
}).start();
}
//如果还有子线程在运行,主线程就让出CPU资源,
//直到所有的子线程都运行完了,主线程再继续往下执行
while(Thread.activeCount() > 1){
Thread.yield();
}
System.out.println("number : " + volDemo.getNumber());
}
}
多次运行程序以后,结果会出现number的值小于500的情况。这是因为程序运行可能出现如下的情况:
例如number = 5,程序按照如下顺序执行:
- 线程A读取number的值
- 线程B读取number的值
- 线程B执行加一操作
- 线程B将最新的值写入内存中
- 线程A执行加一操作
- 线程A将最新的值写入内存中
此时number最终的执行结果为6,少加了1。
保证number自增操作的原子性有如下几种方案:
- 使用synchronized关键字
- 使用ReetrantLock(java.util.concurrent.locks包下)
- 使用AtomicInterger(java.util.concurrent.atomic包下)
第一种:
public void increase(){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
synchronized (this) {
this.number++;
}
}
第二种:
//首先在类中初始化一个lock
private Lock lock = new ReentrantLock();
public void increase(){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
lock.lock();
try {
this.number++;
} finally {
lock.unlock();
}
}
volatile的适用场合:
要在多线程中安全的使用volatile变量,必须同时满足:
- 对变量的写入操作不依赖其当前值
- 不满足:number++,count=count*5等
- 满足:boolean变量,记录温度变化的变量等。
- 该变量没有包含在具有其他变量的不变式中
- 不满足:low<up
四、synchronized和volatile比较
- volatile不需要加锁,比synchronized轻量级,不会阻塞线程。
- 从内存可见性角度看,volatile读相当于加锁,volatile写相当于解锁
- synchronized关键字既能保证原子性,又能保证可见性;而volatile关键字只能保证可见性