public class VolatileTest {
public static void main(String[] args) {
ThreadDemo td = new ThreadDemo();
new Thread(td).start();
while(true){
if(td.getFlag()){
System.out.println("========");
break;
}
}
}
}
class ThreadDemo implements Runnable{
private boolean flag=false;
@Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
flag=true;
System.out.println("flag="+getFlag());
}
public boolean getFlag(){
return flag;
}
}
flag是main thread和td共享的数据，他们都在各自的线程内有一个copy，由于while true的速度十分快，main thread不能读取到td修改后的值，所以只能输出 flag=true。
内存不可见性：当多个thread操作共享数据时，彼此不可见
volatile:当多个thread操作共享数据时，保证数据是可见的，内存栅栏 可以理解为多个线程直接操作主存中的数据
因为使用vloatile 不能指令重排 所以效率低
volatile相比synchronized：
是一种较为轻量级的同步策略，volatile不具备互斥性，两个线程可以同时访问共享数据，volatile不能保证变量的原子性，
原子性问题：i++
以下情况使用volatile不能解决非原子性问题：内存可见性问题依然存在
public class AtomicTest {
public static void main(String[] args) {
AtomicDemo ad = new AtomicDemo();
for(int i=0;i<10;i++){
new Thread(ad).start();
}
}
}
class AtomicDemo implements Runnable{
private int serialNum=0;
@Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+getSerialNum());
}
public int getSerialNum(){
return serialNum++;
}
}
二、使用源自变量 java.util.concurrent.atomic 原子变量包
1.使用volatile保证内存可见性
2.使用CAS compare and swap算法保证数据的原子性
CAS是硬件对于并发操作共享数据的支持
CAS包含三个操作数：
内存值V 预估值A 更新值B
（1）首先读取内存之V 在替换的时候读取旧值A
AtomicInteger:保证线程安全 内存可见性 原子性问题
private AtomicInteger serialNum=new AtomicInteger();
@Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+getSerialNum());
}
public int getSerialNum(){
return serialNum.getAndIncrement();
}
CAS算法的模拟：
public class TestCAS {
public static void main(String[] args) {
final CompareAndSwap cas = new CompareAndSwap();
for(int i=0;i<10;i++){
new Thread(new Runnable() {
@Override
public void run() {
int expectVal = cas.get();
boolean b= cas.compareAndSwap(expectVal,(int)(Math.random()*101));
}
}).start();
}
}
}
class CompareAndSwap {
private int value;
public synchronized int get() {
return value;
}
public synchronized int cas(int expectVal, int newVal) {
int oldVal = value;
if (oldVal == expectVal)
this.value = newVal;
return oldVal;
}
public synchronized boolean compareAndSwap(int expectVal, int newVal) {
return expectVal==cas(expectVal,newVal);
}
}