上一章节我们讲了 volatile的可见性的，以及可见性的演示，这里就会给大家产生一个误区，这样的使用方式很容易给人的感觉是
    对volatile修饰的变量进行并发操作是线程安全的。 其实不然，用volatile修饰的变量只有两个特性就是 可见性、禁止指令重排序。并不能保证线程的安全性
    我们通过以下代码进行演示。

    1.    volatile int iCounter = 0;
    3.     AtomicInteger atomicInteger = new AtomicInteger();
    5.     public static void main(String[] args) throws InterruptedException {
    6.         LatchTest latchTest = new LatchTest();
    7.         latchTest.startTaskAllInOnce(5);
    8.     }
    10.     private void m() throws InterruptedException {
    11.         for (int i = 0; i < 1000000; i++) {
    12.             iCounter++;
    13.             atomicInteger.incrementAndGet();
    14.         }
    15.     }
    17.     public void startTaskAllInOnce(int threadNums) throws InterruptedException {
    18.         final CountDownLatch startGate = new CountDownLatch(1);
    19.         final CountDownLatch endGate = new CountDownLatch(threadNums);
    20.         for (int i = 0; i < threadNums; i++) {
    21.             new Thread(() -> {
    22.                 try {
    23.                     System.out.println("wait thread");
    24.                     startGate.await();
    25.                     try {
    26.                         m();
    27.                     } finally {
    28.                         endGate.countDown();
    29.                     }
    30.                 } catch (InterruptedException ie) {
    31.                     ie.printStackTrace();
    32.                 }
    33.             }).start();
    34.         }
    35.         System.out.println("thread waited");
    36.         startGate.countDown();
    37.         endGate.await();
    39.         System.out.println("iCounter: " + iCounter + " atomicInteger :" + atomicInteger);
    40.     }
    42. 输出结果：
    43. volatile iCounter: 2972488 atomicInteger :5000000
    44. volatile iCounter: 2737312 atomicInteger :5000000
    45. volatile iCounter: 3613868 atomicInteger :5000000
    46. volatile iCounter: 2081604 atomicInteger :5000000
    47. volatile iCounter: 2875711 atomicInteger :5000000
    48. volatile iCounter: 3037079 atomicInteger :5000000
    49. volatile iCounter: 2806466 atomicInteger :5000000
    50. volatile iCounter: 3218029 atomicInteger :5000000
    51. volatile iCounter: 2608899 atomicInteger :5000000
    52. volatile iCounter: 2513628 atomicInteger :5000000
    55. AtomicInteger 是原子性操作，线程安全的，volatile 并不能保证线程安全。

    这是因为虽然 **volatile 保证了内存可见性，每个线程拿到的值都是最新值，但 count++** 这个操作并不是原子的，这里面涉及到获取值、自增、赋值的操作并不能同时完成。

    • 所以想到达到线程安全可以使这三个线程串行执行(其实就是单线程，没有发挥多线程的优势)。
    • 也可以使用** synchronize **或者是锁的方式来保证原子性。
    • 还可以用 **Atomic 包中 AtomicInteger 来替换 int，它利用了 CAS** 算法来保证了原子性。