Java多线程之同步锁定--volatile关键字、原子类

　　使用volatile关键字增加了实例变量在多个线程之间的可见性。但volatile关键字最致命的缺点是不支持原子性。
　　下面将关键字synchronized和volatile进行一下比较:
　　1.)关键字volatile是线程同步的轻量级实现，所以volatile性能肯定比synchronized要好，并且volatile只能修饰于变量，而synchronized可以修饰方法，以及代码块。随着JDK新版本的发布，synchronized关键字在执行效率上得到很大提升，在开发中使用synchronized关键字的比率还是比较大的。
　　2)多线程访问volatile不会发生阻塞，而synchronized会出现阻塞。
　　3)volatile能保证数据的可见性，但不能保证原子性;而synchronized可以保证原子性，也可以间接保证可见性，因为它会将私有内存和公共内存中的数据做同步。此知识点在后面有实验做论证。
　　4)再次重申一下，关键字volatile解决的是变量在多个线程之间的可见性;而synchronized关键字解决的是多个线程之间访问资源的同步性。
　　线程安全包含原子性和可见性两个方面，Java的同步机制都是围绕这两个方面来确保线程安全的。

1、volatile非原子的特性

　　关键字volatile虽然增加了实例变量在多个线程之间的可见性，但它却不具备同步性，那么也就不具备原子性。下面用项目来进行测试。
1.使用volatile ，方法没有synchronized

public class MyThread extends Thread {
    public volatile static int count;  //使用volatile

    private static void addCount() {
        for (int i=0; i<100; i++) {
            count++;
        }
        System.out.println("count=" + count);
    }

    public void run() {
        addCount();
    }
}
public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyThread[] myThreadArray = new MyThread[100];
        for (int i=0; i<100; i++) {
            myThreadArray[i] = new MyThread();
        }

        for (int i=0; i<100; i++) {
            myThreadArray[i].start();
        }
    }
}

……
count=9599
count=9899
count=9899
count=9899

2.将上面的MyThread类修改，方法使用synchronized

public class MyThread extends Thread {
    public volatile static int count;  //使用volatile

    //注意这个例子里一定要加static关键字
    //这样的synchronized与static锁的内容就是MYThread.java类了，也就达到同步的效果了
    private synchronized static void addCount() {
        for (int i=0; i<100; i++) {
            count++;
        }
        System.out.println("count=" + count);
    }

    public void run() {
        addCount();
    }
}

……
count=9700
count=9800
count=9900
count=10000
　　在本示例的意图中，如果在方法private static void addCount()前加人synchronized同步关键字，也就没有必要再使用volatile关键字来声明count变量了。
　　
　　关键字volatile主要使用的场合是在多个线程中可以感知实例变量被更改了，并且可以获得最新的值使用，也就是用多线程读取共享变量时可以获得最新值使用。
　　关键字volatile提示线程每次从共享内存中读取变量，而不是从私有内存中读取，这样就保证了同步数据的可见性。但在这里需要注意的是:如果修改实例变量中的数据，比如i++，也就是i=i+ 1，则这样的操作其实并不是一个原子操作，也就是非线程安全的。表达式i++的操作步骤分解如下:
　　1)从内存中取出i的值;
　　2)计算i的值;
　　3)将i的值写到内存中。
　　假如在第2步计算值的时候，另外一个线程也修改i的值，那么这个时候就会出现脏数据。解决的办法其实就是使用synchronized关键字，这个知识点在前面的案例中已经介绍过了。所以说volatile本身并不处理数据的原子性，而是强制对数据的读写及时影响到主内存的。
原因是Java的自动封箱和解箱操作在作怪。
　　这里的i++实际上是i = new Integer(i+1)，所以执行完i++后，i已经不是原来的对象了，同步块自然就无效了。
其它基本类型的封装类，如Short、Long等等也不能作为同步对象
　　用图来演示一下使用关键字volatile时出现非线程安全的原因。变量在内存中工作的过程如图所示。
　　
　　由上，我们可以得出以下结论。
　　1)read和load阶段:从主存复制变量到当前线程工作内存;
　　2)use和assign阶段:执行代码，改变共享变量值;
　　3)store和州to阶段:用工作内存数据刷新主存对应变量的值。

2、使用原子类进行i++操作

　　除了在i++操作时使用synchronized关键字实现同步外，还可以使用AtomicInteger原子类进行实现。
　　原子操作是不能分割的整体，没有其他线程能够中断或检查正在原子操作中的变量。一个原子(atomic)类型就是一个原子操作可用的类型，它可以在没有锁的情况下做到线程安全(thread-safe).

public class AddCountThread extends Thread {
    private AtomicInteger count = new AtomicInteger(0); // 原子类

    public void run() {
        for (int i=0; i<10000; i++) {
            System.out.println(count.incrementAndGet());
        }
    }
}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        AddCountThread countService = new AddCountThread();
        Thread t1 = new Thread(countService);
        t1.start();
        Thread t2 = new Thread(countService);
        t2.start();
        Thread t3 = new Thread(countService);
        t3.start();
        Thread t4 = new Thread(countService);
        t4.start();
        Thread t5 = new Thread(countService);
        t5.start();
    }
}

……
49995
49996
49997
49998
49999
50000
成功累加到50000

---

3、原子类也并不完全安全

　　原子类在具有有逻辑的情况下输出结果也具有随机性。

public class MyService {
    public static AtomicLong aiRef = new AtomicLong();
    public void addNum() {  //在这个例子中，这里如果不加synchronized，输出的结果是随机的
        System.out.println(Thread.currentThread().getName() + " 加了100之后的值是： "
                + aiRef.addAndGet(100));
        aiRef.addAndGet(1);
    }
}

public class MyThread extends Thread {
    private MyService myService;
    public MyThread(MyService myService) {
        this.myService = myService;
    }
    public void run() {
        myService.addNum();
    }
}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
        MyThread[] array = new MyThread[5];
        for (int i=0; i<array.length; i++) {
            array[i] = new MyThread(service);
        }

        for (int i=0; i<array.length; i++) {
            array[i].start();
        }
        Thread.sleep(1000);
        System.out.println(service.aiRef.get());
    }
}

Thread-3 加了100之后的值是： 100
Thread-4 加了100之后的值是： 201
Thread-0 加了100之后的值是： 302
Thread-1 加了100之后的值是： 502
Thread-2 加了100之后的值是： 402
505
　　出现这样的情况是因为addAndGet()方法是原子的，但方法和方法之间的调用却不是原子的。解决这样的问题必须要用同步，即在MyService类的addNum()方法前加synchronized，则会有如下 的结果
Thread-1 加了100之后的值是： 100
Thread-3 加了100之后的值是： 201
Thread-2 加了100之后的值是： 302
Thread-4 加了100之后的值是： 403
Thread-0 加了100之后的值是： 504
505

public class Service {
    private boolean isContinueRun = true;
    public void runMethod() {
        while (isContinueRun == true) {
        }
        System.out.println("停下来了！");
    }
    public void stopMethod() {
        isContinueRun = false;
    }
}
public class MyThread1 extends Thread {
    private Service service;

    public MyThread1(Service service) {
        super();
        this.service = service;
    }

    public void run() {
        service.runMethod();
    }
}
public class MyThread2 extends Thread{
    private Service service;

    public MyThread2(Service service) {
        super();
        this.service = service;
    }

    public void run() {
        service.stopMethod();
    }
}
public class Run {
    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        MyThread1 a = new MyThread1(service);
        a.start();
        Thread.sleep(2000);

        MyThread2 b = new MyThread2(service);
        b.start();
        System.out.println("已经发起停止的命令了！");
    }
}

已经发起停止的命令了！
出现死循环
　　得到这个结果是各线程间的数据值没有可视性造成的，而关键字synchronized可以具有可视性。更改Service

public class Service {
    private boolean isContinueRun = true;
    public void runMethod() {
        String anyString = new String();
        while (isContinueRun == true) {
            synchronized (anyString) {
            }
        }
        System.out.println("停下来了！");
    }
    public void stopMethod() {
        isContinueRun = false;
    }
}

已经发起停止的命令了！
停下来了！
可以正常退出。
　　关键字synchronized可以保证在同一时刻，只有一个线程可以执行某一个方法或某一个代码块。它包含两个特征:互斥性和可见性。同步synchronized不仅可以解决一个线程看到对象处于不一致的状态，还可以保证进人同步方法或者同步代码块的每个线程，都看到由同一个锁保护之前所有的修改效果。
　　学习多线程并发，要着重“外练互斥，内修可见”，这是掌握多线程、学习多线程并发