synchronized,volatile都解决了共享变量 value 的内存可见性问题，但是前者是独占锁，同时只能有一个线程调用 get()方法，其他调用线程会被阻塞， 同时会存在线程上下文切换和线程重新调度的开销，这也是使用锁方式不好的地方。 而后者是非阻塞算法，不会造成线程上下文切换的开销。
volatile 虽然提供了可见性保证，但并不保证操作的原子性。
一般在什么时候才使用 volatile 关键字呢？
- 写入变量值不依赖、变量的当前值时。 因为如果依赖当前值，将是获取一计算一写入 三步操作，这三步操作不是原子性的，而 volatile 不保证原子性。
- 读写变量值时没有加锁。 因为加锁本身已经保证了内存可见性，这时候不需要把变量声明为 volatile 的。
/**
* volatile不能代替锁
* volatile无法保证i++的原子性操作
*/
public class VolatileDemo {
static volatile int i = 0;
public static class PlusTask implements Runnable {
@Override
public void run() {
// synchronized (VolatileDemo.class){
for (int j = 0; j < 10000; j++) {
i++;
}
// }
}
}
public static void main(String[] args) throws InterruptedException{
Thread[] threads = new Thread[10];
for (int a = 0; a < 10; a++) {
threads[a] = new Thread(new PlusTask());
threads[a].start();
}
for (int a = 0; a < 10; a++) {
threads[a].join();
}
System.out.println(i);//i的值小于10000
}
}
//可见性
public class NoVisibility {
private static volatile boolean ready;
private static int number;
public static class ReadThread extends Thread{
@Override
public void run() {
while (!ready); //没使用volatile声明ready前,主线程修改ready的状态，ReadThread无法"看到"主线程中的修改
System.out.println(number);
}
}
public static void main(String[] args) throws InterruptedException{
ReadThread readThread = new ReadThread();
readThread.start();
Thread.sleep(1000);
number = 42;
ready = true;
Thread.sleep(1000);
}
}