感谢这两位博主的文章，文章源于：
https://www.cnblogs.com/chenpi/p/5375805.html
https://blog.csdn.net/fanrenxiang/article/details/80623884
版本：dk1.5后提供了，java.util.concurrent.atomic包
作用：方便程序员在多线程环境下，无锁的进行原子性操作
底层：原子变量的底层使用了处理器提供的原子指令，但是不同的CPU架构可能提供的原子指令不一样，也有可能需要某种形式的内部锁,所以该方法不能绝对保证线程不被阻塞
内部核心：Atomic包里内部实现不是简单的使用synchronized，而是一个更为高效的方式CAS (compare and swap) + volatile和native方法（同步的工作更多的交给了硬件），从而避免了synchronized的高开销，执行效率大为提升
关于CAS：
compare and swap，比较和替换技术，将预期值与当前变量的值比较(compare)，如果相等则使用新值替换(swap)当前变量，否则不作操作；
现代CPU已广泛支持CAS指令，如果不支持，那么JVM将使用自旋锁，与互斥锁一样，两者都需先获取锁才能访问共享资源，但互斥锁会导致线程进入睡眠，而自旋锁会一直循环等待直到获取锁；
另外，有一点需要注意的是CAS操作中的ABA问题，即将预期值与当前变量的值比较的时候，即使相等也不能保证变量没有被修改过，因为变量可能由A变成B再变回A,解决该问题，可以给变量增加一个版本号，每次修改变量时版本号自增，比较的时候，同时比较变量的值和版本号即可；
Atomic包中原子方式基本更新类型：
1.AtomicBoolean：原子更新布尔类型。
2.AtomicInteger：原子更新整型。
3.AtomicLong：原子更新长整型。
以AtomicInteger为例，源码：
package concurrency;
import java.util.concurrent.atomic.AtomicInteger; public class AtomicIntegerTest { static AtomicInteger ai = new AtomicInteger(1); public static void main(String[] args) {
//相当于i++,返回的是旧值,看方法名就知道，先获取再自增
System.out.println(ai.getAndIncrement());
System.out.println(ai.get());
//先自增，再获取
System.out.println(ai.incrementAndGet());
System.out.println(ai.get());
//增加一个指定值，先add，再get
System.out.println(ai.addAndGet(5));
System.out.println(ai.get());
//增加一个指定值,先get，再set
System.out.println(ai.getAndSet(5));
System.out.println(ai.get());
} }
为什么需要AtomicInteger原子操作类？
对于Java中的运算操作，例如自增或自减，若没有进行额外的同步操作，在多线程环境下就是线程不安全的。num++解析为num=num+1，明显，这个操作不具备原子性，多线程并发共享这个变量时必然会出现问题。测试代码如下:
public class AtomicIntegerTest {
private static final int THREADS_CONUT = 20;
public static int count = 0;
public static void increase() {
count++;
}
public static void main(String[] args) {
Thread[] threads = new Thread[THREADS_CONUT];
for (int i = 0; i < THREADS_CONUT; i++) {
threads[i] = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
increase();
}
}
});
threads[i].start();
}
while (Thread.activeCount() > 1) {
Thread.yield();
}
System.out.println(count);
}
}这里运行了20个线程，每个线程对count变量进行1000此自增操作，如果上面这段代码能够正常并发的话，最后的结果应该是20000才对，但实际结果却发现每次运行的结果都不相同，都是一个小于20000的数字。
再用AtomicInteger：
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicIntegerTest {
private static final int THREADS_CONUT = 20;
public static AtomicInteger count = new AtomicInteger(0);
public static void increase() {
count.incrementAndGet();
}
public static void main(String[] args) {
Thread[] threads = new Thread[THREADS_CONUT];
for (int i = 0; i < THREADS_CONUT; i++) {
threads[i] = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
increase();
}
}
});
threads[i].start();
}
while (Thread.activeCount() > 1) {
Thread.yield();
}
System.out.println(count);
}
}结果每次都输出20000，程序输出了正确的结果，这都归功于AtomicInteger.incrementAndGet()方法的原子性。
注意：Atomic包提供了三种基本类型的原子更新，剩余的Java的基本类型还有char，float和double等，其更新方式可以参考AtomicBoolean的思路来现，AtomicBoolean是把boolean转成整型再调用compareAndSwapInt进行CAS来实现的，类似的short和byte也可以转成整形，float和double可以利用Float.floatToIntBits，Double.doubleToLongBits转成整形和长整形进行相应处理；
在中低程度的竞争下，原子类提供更高的伸缩性；在高强度的竞争下，锁能更好的帮助我们避免竞争。（来自《并发编程实战》）
所以，我们要视情况而定，若资源竞争规模不大，控制粒度较小，使用原子类比使用锁更好，能提高效率与性能