i++为什么是线程不安全的

分析：

如果是全局变量，i++是不安全的，因为java在操作i++的时候，是分步骤做的，可以理解为：
temp = i;
temp2 = i+1;
i=temp2;
如果线程1在执行第一条代码的时候，线程2访问i变量，这个时候，i的值还没有变化，还是原来的值，所以是不安全的。

从更底层的角度讲，主要是因为i++这个操作不是原子性的，这个会编译成i= i +1； 所以会出现多线程访问冲突问题。volatile虽然可以保证多线程对修改可见，但代码中用到了
i++， 主要是i++不是原子性操作，这个会编译成i = i +1，其实是做了3个步骤，一个是读取，修改，写入 。所以会出现多线程访问冲突问题

解决方案：

在Java语言中，++i和i++操作并不是线程安全的，在使用的时候，不可避免的会用到synchronized关键字。而java.util.concurrent.AtomicInteger是一个提供原子操作的Integer类，其提供了线程安全且高效的原子操作，是线程安全的。

AtomicInteger类的底层实现原理是利用处理器的CAS操作（Compare And Swap，比较与交换，一种有名的无锁算法）来检测栈中的值是否被其他线程改变，如果被改变则CAS操作失败。这种实现方法在CPU指令级别实现了原子操作，因此，其比使用synchronized来实现同步效率更高。

CAS操作过程都包含三个运算符：内存地址V、期望值E、新值N。当操作的时候，如果地址V上存放的值等于期望值E，则将地址V上的值赋为新值N，否则，不做任何操作，但是要返回原值是多少。这就保证比较和设置这两个动作是原子操作。系统主要利用JNI（Java Native Interface，Java本地接口）来保证这个原子操作，它利用CPU硬件支持来完成，使用硬件提供swap和test_and_set指令，但CPU下同一指令的多个指令周期不可中断，SMP（Symmetric Multi-Processing）中通过锁总线支持这两个指令的原子性

示例代码：

　　

package com.tree.blog.pool.cas;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class AtomicTest {

     volatile  int initialValue=1;
     //Atomic包下的是基于CAS实现的，是线程安全的，不需要加锁
     AtomicInteger initialAtomicValue=new AtomicInteger(1);

    /**
     * i++ 是线程不安去的
     *   这个语句在执行的时候实际分为了三部
     *   1、在栈中给一个 tp=i
     *   2、执行i+1,    tp2=i+1
     *   3、赋值 给i完成，i=tp2
     *   如果线程1在执行第一条代码的时候，线程2访问i变量，这个时候，i的值还没有变化，还是原来的值，所以是不安全的
     * @param args
     */
    public static void main(String[] args)  {
        AtomicTest test = new AtomicTest();
        ExecutorService executorService = Executors.newFixedThreadPool(3000);
        //使用Callable+future可以接受返回值其它的不行
        Runnable run = test::increment;
        Runnable runLock = test::incrementWithLock;
        Runnable atomicRun = test::atomicIncrement;
        //线程不安全，会出现多个线程得到相同的值
        for (int i = 0; i <1000 ; i++) {
            executorService.submit(run);
        }
        //同步锁，不会出粗，并发性能低
        for (int i = 0; i <1000 ; i++) {
           executorService.submit(runLock);
        }
        //使用基于CAS实现的原子操作，不错出现重复
        for (int i = 0; i <1000 ; i++) {
            executorService.submit(atomicRun);
        }
        executorService.shutdown();
    }

    /**
     * 同步锁 执行自增
     * @return
     */
   public synchronized  int incrementWithLock(){
       System.out.println("线程名称："+Thread.currentThread().getName()+"-当前值："+initialValue);
        return initialValue++;
   }
    /**
     * 执行自增
     * @return
     */
    public  int increment(){
        System.out.println("线程名称："+Thread.currentThread().getName()+"-当前值："+initialValue);
        return initialValue++;
    }

    /**
     * 同步锁 执行自增
     * @return
     */
    public synchronized int atomicIncrement(){
        System.out.println("线程名称："+Thread.currentThread().getName()+"-当前值："+initialAtomicValue.get());
        return initialAtomicValue.getAndIncrement();
    }
}

　　参考：

　　https://www.jianshu.com/p/ae25eb3cfb5d