在内存模型基础中已经提到过,JVM是分为堆内存和栈内存的,堆内存在线程之间共享,而栈内存为线程内部私有,对其他线程不可见。为保证变量的可见性,可以使用volatile修饰,那为什么使用了关键字volatile修饰后,就能保证可见性,下面进行分析。
volatile 可以看作是一个轻量级的锁,这么说可能是不准确的,但它确实具备了锁的一些特性。与锁的区别是,锁保证原子性,锁住的可能是是个变量或者一段代码,而volatile修饰的变量只能保证变量在线程之间的传递,只能保证可见性,在一些方面并没有具备原子性。
所以上面的话有两层语义:
- 保证可见性,不保证原子性
- 禁止指令的重排序（重排序会破坏volatile的内存语义）
volatile变量的读写可以实现线程之间的通信。
volatile内存语义
- 写的内存语义： 当写一个volatile变量时,JMM会把线程对应的本地内存中的共享变量刷新到主内存。
- 读的内存语义： 当读一个volatile变量时，JMM会把线程对应的本地内存置为无效，线程接下来从主内存中读取共享变量。
初始时，两个线程的本地内存中的flag和a都是初始状态，线程A在写flag变量后，本地内存A中更新过的两个共享变量的值被刷新到主内存中，
在读flag变量后，本地内存中包含的值已经被置为无效，此时线程B必须从主内存中读取共享变量。
jdk1.5以后，对每一个线程做了优化，每个线程都加了一块独立的内存空间。内部装了主内存变量的副本，该线程直接取内存空间副本的值。
/**
* @Description TODO
* @Author "zhouhai"
* @Date2018/10/816:46
**/
public class RunThread extends Thread{
private "volatile" boolean isRunning = true;
private void setRunning(boolean isRunning) {
this.isRunning = isRunning;
}
public void run() {
System.out.println("进入run方法..");
while (isRunning == true) {
}
System.out.println("线程停止");
}
public static void main(String[] args) throws InterruptedException {
RunThread rt = new RunThread();
rt.start();
Thread.sleep(3000);
rt.setRunning(false);
System.out.println("isRunning的值已经被设置了false");
Thread.sleep(1000);
System.out.println(rt.isRunning);
}
}
加了volatile后的运行结果：
进入run方法..
isRunning的值已经被设置了false
线程停止
false
同一份变量在rt线程和main线程实现了可见性
从汇编层看volatile关键字
记得曾经看过一篇文章，讲述的是volatile关键字修饰的变量，编程汇编代码后，会在变量的前面插入一条LOCK指令。
Java代码: instance = new Singleton();//instance是volatile变量
汇编代码: 0x01a3de1d: movb0x0,(%esp);
通过上面的代码发现，volatile修饰的变量会多出一个lock指令，LOCK指令属于系统层级： LOCK前缀会使处理器执行当前指令时产生一个LOCK#信号，显示的锁定总线。
来看一下LOCK指令的作用：
锁总线：其他cpu对内存的读写请求会被阻塞，直到锁释放，不过因为锁总线的的开销太大，后来采用锁缓存来代替锁总线
lock后的写操作会回写已修改的数据，同时让其它cpu相关缓存行失效，从而重新从主存中加载最新的数据
不是内存屏障却完成类似内存屏障的功能，阻止屏障两边的执行重排序
volatile并不具备原子性
import java.util.concurrent.atomic.AtomicInteger;
/**
* @Description TODO
* @Author "zhouhai"
* @Date2018/10/910:05
**/
public class VolatileNoAtomic extends Thread {
/**
* private static volatile int count;
*/
private static AtomicInteger count = new AtomicInteger(0);
private static void addCount() {
for (int i = 0; i < 1000; i++) {
//count++;
count.incrementAndGet();
}
System.out.println(count);
}
@Override
public void run() {
addCount();
}
public static void main(String[] args) {
VolatileNoAtomic[] arr = new VolatileNoAtomic[10];
for (int i = 0; i < 10 ; i++) {
arr[i] = new VolatileNoAtomic();
}
for (int i = 0; i < 10 ; i++) {
arr[i].start();
}
}
}
volatile并不能保证原子性，可以用AtomicInteget count 代替 volatile int count ,count.incrementAndGet()代替count++
3000
3000
3000
4000
5000
6000
7000
8000
9000
10000
要实现原子性建议使用atomic类的系列对象，支持原子性操作(注意atomic类只保证本身方法的原子性，并不保证多次操作的原子性)
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @Description TODO
* @Author "zhouhai"
* @Date2018/10/910:19
**/
public class AtomicUse {
private static AtomicInteger count = new AtomicInteger(0);
//多个addAndGet在一个方法内是非原子性的，需要加synchronized进行修饰，保证4个addAndGet整体原子性
public int multiAdd() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
count.addAndGet(1);
count.addAndGet(2);
count.addAndGet(3);
count.addAndGet(4);
return count.get();
}
public static void main(String[] args) {
final AtomicUse au = new AtomicUse();
List<Thread> ts = new ArrayList<>();
for (int i = 0; i <100 ; i++) {
ts.add(new Thread(new Runnable() {
@Override
public void run() {
System.out.println(au.multiAdd());
}
}));
}
for (Thread t : ts) {
t.start();
}
}
}
20
40
30
20
50
80
90
70
60
100
110
130
120
140
150
166
190
180
170
200
210
220
240
230
250
260
270
280
300
290
310
320
330
340
350
360
370
380
390
400
410
420
430
450
440
520
530
560
510
500
581
480
470
620
660
460
490
650
640
630
610
600
590
571
710
550
540
700
690
720
680
670
730
740
750
760
770
780
790
800
970
960
950
940
930
920
910
900
890
880
870
860
850
840
830
820
810
1000
990
980
总结
volatile是一种比锁更轻量级的线程之间通信的机制，volatile仅仅保证对单个volatile变量的读/写具有原子性，而锁的互斥执行的特性可以保证对整个临界区代码执行具有原子性，在功能上，锁比voatile更强大，在可伸缩性和执行性能上，volatile更有优势，但是volatile并不能代替锁。
