在Java语言中，++i和i++操作并不是线程安全的，在使用的时候，不可避免的会用到synchronized关键字。而AtomicInteger则通过一种线程安全的加减操作接口。
没上锁的 Integer ++ ,执行多几次，得到的数值大多数都是小于200000，但是这个是我们不想得到的结果
class MyThread implements Runnable { static volatile long i = 0; public void run() { for (int m = 0; m < 100000; m++) { i++; } } }; public class TestAtomicInteger { public static void main(String[] args) throws InterruptedException { MyThread mt = new MyThread(); Thread t1 = new Thread(mt); Thread t2 = new Thread(mt); t1.start(); t2.start(); Thread.sleep(500); System.out.println(MyThread.i); } }
可以不用synchronized，使用AtomicInteger完成这个操作
class MyThread implements Runnable { // static int i = 0; static AtomicInteger ai = new AtomicInteger(0); public void run() { for (int m = 0; m < 1000000; m++) { ai.getAndIncrement(); } } }; public class TestAtomicInteger { public static void main(String[] args) throws InterruptedException { MyThread mt = new MyThread(); Thread t1 = new Thread(mt); Thread t2 = new Thread(mt); t1.start(); t2.start(); Thread.sleep(500); System.out.println(MyThread.ai.get()); } }
可以发现结果都是2000000，也就是说AtomicInteger是线程安全的。
atomicinteger源码部分讲解
public class AtomicInteger extends Number implements java.io.Serializable { private static final long serialVersionUID = 6214790243416807050L; // setup to use Unsafe.compareAndSwapInt for updates private static final Unsafe unsafe = Unsafe.getUnsafe(); private static final long valueOffset; static { try { valueOffset = unsafe.objectFieldOffset (AtomicInteger.class.getDeclaredField("value")); } catch (Exception ex) { throw new Error(ex); } } private volatile int value;
以上为AtomicInteger中的部分源码，在这里说下其中的value，这里value使用了volatile关键字，volatile在这里可以做到的作用是使得多个线程可以共享变量，但是问题在于使用volatile将使得VM优化失去作用，导致效率较低，所以要在必要的时候使用，因此AtomicInteger类不要随意使用，要在使用场景下使用。
