Java的高并发编程系列（二）volatile

挥发性关键字，使一个变量在多个线程间可见
A B线程都用到一个变量，java默认是A线程中保留一份copy，这样如果B线程修改了该变量，则A线程未必知道，使用volatile关键字，会让所有线程都会读到变量的修改值。

在下面的代码中，running是存在于堆内存的t对象中
当线程t1开始运行的时候，会把running值从内存中读到t1线程的工作区，在运行过程中直接使用这个copy，并不会每次都去读取堆内存，这样，当主线程修改running的值之后，t1线程感知不到，所以不会停止运行，使用volatile，将会强制所有线程都去堆内存中读取running的值。
可以阅读这篇文章进行更深入的理解
http://www.cnblogs.com/nexiyi/p/java_memory_model_and_thread.html

public class Demo12 {
    volatile boolean running = true;
    public void test(){
        System.out.println("test start.......");
        while (running) {
            /*try { TimeUnit.SECONDS.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); }*/
        }
        System.out.println("test end........");
    }
    public static void main(String[] args) {
        Demo12 demo12 = new Demo12();
        new Thread(demo12 :: test, "t1").start(); //JDK1.8新特性
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        demo12.running = false;
    }
}

volatile的效率要比synchronized高很多。synchronized是重量级锁，在java7后轻了很多。
volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized

public class Demo13 {
    /** volatile **/ int count = 0;
    public /**synchronized**/ void test(){
        for (int i = 0; i < 10000; i++) {
            count ++;
        }
    } 
    public static void main(String[] args) {
        Demo13 demo13 = new Demo13();   
        List<Thread> threads = new ArrayList<Thread>();
        for (int i = 0; i < 10; i++) {
            threads.add(new Thread(demo13::test, "thread-" + i));
        }
        threads.forEach((o)->o.start()); //JDK1.8新特性
        threads.forEach((o)->{ //JDK1.8新特性
            try {
                o.join(); //等线程执行完毕之后才执行主线程main
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        System.out.println(demo13.count);
    }
}

//int count = 0;
AtomicInteger count = new AtomicInteger(0);
public /*synchronized*/ void test(){
        for (int i = 0; i < 10000; i++) {
            //count ++;
            count.incrementAndGet(); //count++ 
        }
    }

incrementAndGet是具有原子性的，不可分的，也可实现。
解决同样的问题的更高效的方法，使用AtomXXX类
AtomXXX类本身方法都是原子性的，但不能保证多个方法连续调用是原子性

volatile只能保证可见性，并不能保证原子性，synchronized可保证两者。

synchronize优化
同步代码快中的语句越少越好

int count = 0;

public synchronized void test1(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //业务逻辑中只有下面这句需要sync，这时不应该给整个方法上锁
        count ++;

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

public void test2(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //业务逻辑中只有下面这句需要sync，这时不应该给整个方法上锁
        //采用细粒度的锁，可以是线程争用时间变短，从而提高效率
        synchronized (this) {
            count ++;
        }

    try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

test2只锁定需要的部分，是细粒度的锁，比粗粒度的锁效率较高。