Java[学习] Volatile总结

Java 里面解决并发问题的有：加锁（SynChronized,lock）,利用管道进行线程间通信， 阻塞队列（BlockingQueue），使用Java大牛Doug Lea写的Executors/Executor/ExecutorService/ThreadPoolExecutor,使用计数器CountDownLatch来控制

介绍volatile

在Java线程并发处理中，Java引入了Volatile变量。这次主要说说这个变量

在jdk1.2之前 Java内存模型的实现是总主内存（即共享内存）读取变量，不需要特别注意，但是随着jvm的发展和成熟，当前内存模型下，线程是将变量存在本地内存中（比如机器的寄存器），而不是直接从主存中进行读写，而这就造成了主存和寄存器的数据不统一。

要解决这个问题，Java给出了Volatile变量，用Volatitle修饰的变量，在每次线程访问时，都强迫从共享内存中读取数据成员变量，当成员变量发生变化时，强迫线程变化值写到共享内存中，这样，在任何时刻，两个不同线程总是看到弄个成员变量的同一个值。

Volatile 是一宗削弱的同步机制，在访问Volatile 修饰的变量时候不会执行加锁操作，也就不会执行线程阻塞，因此volatilei变量是一种比synchronized关键字更轻量级的同步机制。

##使用##
Java内存包含以下三种情况

1. 原子性
2. 有序性
3. 可见性

Volatile两层语义

• 保证不同线程对这个变量进行的操作的可见性，即一个线程修改某个变量的值，这新值对其他线程是立即可见的
• 禁止进行指令重排

那么volatile能保证原子性吗？

下面的例子

public class VolatileTest {


    public static void main(String args[]) {
        for (int i = 0; i < 10000; i++) {
            new Thread(new VoRunnable()).start();
        }
    }

    static class VoRunnable implements Runnable {
        static volatile int ic = 0;

        @Override
        public void run() {
            ic++;
			System.out.println("ic = "+ic);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：有一点概率，但是如果把线程开的越多，则结果会越明显，最后的值不一定能加到10000，所以表明Volatile是不能保证原子性的。

原理：自增操作不是原子性的，而且Volatile也无法保证对变量的操作都是原子性的。

如要保证原子性可以使用synchronized、lock、AtomicInteger等。

那么volatile能保证有序性吗？

例子

public class VolatileTest {

    static String sbu  = null;
    static volatile boolean inited = true;

    public static void main(String args[]) {
        for (int i = 0; i < 101; i++) {
            new Thread(new VoRunnable2(i)).start();
        }
        new Thread(new VoRunnable()).start();
    }

    static class VoRunnable2 implements Runnable{

        volatile int ic = 0;

        VoRunnable2(int i){
            this.ic = i;
        }

        @Override
        public void run() {
            System.out.println("ic = "+ ic);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(ic == 100){
                sbu = new String("123456");
                inited = false;
            }
        }
    }

    static class VoRunnable implements Runnable {
        static volatile int ic = 0;

        @Override
        public void run() {
            while (inited){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            if(sbu == null){
                System.out.println(" sbu = kong" );
            }else {
                System.out.println(" sbu = " + sbu);
            }
        }
    }
}

上述程序运行结果表明：只要Volatile对inited，进行修饰，就不会出现这种问题。

总结

1. 它确保指令重排序时不会把其后面的指令排到内存 屏障之前的位置，也不会把前面的指令排到内存屏障的后面； 即在执行到内存屏障这句指令时，在它前面的操作已经全部 完成
2. 它会强制将对缓存的修改操作立即写入主存
3. 如果是写操作，它会导致其他 CPU 中对应的缓存行 无效。