volatile的一个坑！

volatile不会进行线程的互斥处理

来自图解ava多线程设计模式的一张内存模型的原理图

代码如下：

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;

public class M {

    //volatile的两个功能：
    //1.防止重排序
    //2.可见性：线程A对volatile字段进行的写操作的结果对其他线程立即可见（因为volatile字段不缓存在缓存中）
    //这里的缓存指的是cpu的寄存器、cpu内部的缓存（L1、L2）、java虚拟机临时保存的变量
    //但是volatile不会进行线程的互斥处理
    volatile int n = 0;
    /**
     * @param args
     */
    public static void main(String[] args) {
        final M m = new M();
        //保证main线程等待5个线程执行完后，main线程才会继续执行
        final CountDownLatch la = new CountDownLatch(5);
        //让5个线程同时运行
        final CyclicBarrier cb = new CyclicBarrier(5, new Runnable() {

            @Override
            public void run() {
                System.out.println("inside barrier");
            }
        });
        for(int i = 0; i < 5; ++i) {
            new Thread() {

                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + " waitting");
                    try {
                        cb.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                    for(int j = 0; j < 1000; ++j) {
                        m.n++;
                    }
                    System.out.println(currentThread().getName() + " done");
                    la.countDown();
                }

            }.start();
        }

        try {
            la.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(m.n);
    }

}

结果

第一次运行的结果

再一次运行的结果