当程序更新一个变量时，如果多线程同时更新这个变量，可能得到期望之外的值，比如变量i=1，A线程更新i+1，B线程也更新i+1，经过两个线程操作之后可能i不等于3，而是等于2。因为A和B线程在更新变量i的时候拿到的i都是1，这就是线程不安全的更新操作，通常我们会使用synchronized来解决这个问题，synchronized会保证多线程不会同时更新变量i。
而Java从JDK 1.5开始提供了java.util.concurrent.atomic包（以下简称Atomic包），这个包中的原子操作类提供了一种用法简单、性能高效、线程安全地更新一个变量的方式。
因为变量的类型有很多种，所以在Atomic包里一共提供了12个类，属于4种类型的原子更新方式，分别是原子更新基本类型、原子更新数组、原子更新引用和原子更新属性（字段）。Atomic包里的类基本都是使用Unsafe实现的包装类。

原子更新基本类型

使用原子的方式更新基本类型，Atomic包提供了以下3个类。

• AtomicBoolean：原子更新布尔类型。
• AtomicInteger：原子更新整型。
• AtomicLong：原子更新长整型。

以上3个类提供的方法几乎一模一样，所以本节仅以AtomicInteger为例进行讲解，AtomicInteger的常用方法如下：

• int addAndGet（int delta）：以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果。
• boolean compareAndSet（int expect，int update）：如果输入的数值等于预期值，则以原子方式将该值设置为输入的值。
• int getAndIncrement()：以原子方式将当前值加1，注意，这里返回的是自增前的值。同理还有getAndDecrement()、incrementAndGet()、decrementAndGet()、get()等
• void lazySet（int newValue）：最终会设置成newValue，使用lazySet设置值后，可能导致其他线程在之后的一小段时间内还是可以读到旧的值。
• int getAndSet（int newValue）：以原子方式设置为newValue的值，并返回旧值。

示例代码：

原子更新数组

通过原子的方式更新数组里的某个元素，Atomic包提供了以下类：

• AtomicIntegerArray：原子更新整型数组里的元素。
• AtomicLongArray：原子更新长整型数组里的元素。
• AtomicReferenceArray：原子更新引用类型数组里的元素。

AtomicIntegerArray类主要是提供原子的方式更新数组里的整型，其常用方法如下：

• int addAndGet（int i，int delta）：以原子方式将输入值与数组中索引i的元素相加。
• boolean compareAndSet（int i，int expect，int update）：如果当前值等于预期值，则以原子方式将数组位置i的元素设置成update值。

以上几个类提供的方法几乎一样，所以仅以AtomicIntegerArray为例进行讲解，示例代码如下：

原子更新引用类型

原子更新基本类型的AtomicInteger，只能更新一个变量，如果要原子更新多个变量，就需要使用这个原子更新引用类型提供的类。Atomic包提供了以下3个类。

• AtomicReference：原子更新引用类型。
• AtomicReferenceFieldUpdater：原子更新引用类型里的字段。
• AtomicMarkableReference：原子更新带有标记位的引用类型。可以原子更新一个布尔类型的标记位和引用类型。构造方法是AtomicMarkableReference（V initialRef，boolean initialMark）。

示例代码：

class User{
     public volatile String name;
     public volatile String addr;
     public volatile int age;
}

//AtomicReference示例代码：
AtomicReference<User> auser = new AtomicReference<AtomicTest.User>();
User user = new User("mm", "hangzhou", 5);
auser.set(user);                 //原子方式设置对象
System.out.println("new name: "+auser.get().getName());   //原子方式获取对象
System.out.println("new age: "+auser.get().getAge());
User useru = new User("dd", "ningbo", 15);
User old = auser.getAndSet(useru);       //获取原有对象，设置新的对象。
System.out.println("old name: "+old.getName());
System.out.println("update name: "+auser.get().getName());
System.out.println("update age: "+auser.get().getAge());
auser.compareAndSet(useru, new User("", "", 0));
/*如果对useru对象进行改变，auser对应数据也会发生改变。
与AtomicIntegerArray不同，AtomicReference与原先的对象是绑定的。同时发生变化。*/

//AtomicReferenceFieldUpdater示例代码：
AtomicReferenceFieldUpdater<User, String> nameUp = 
AtomicReferenceFieldUpdater.newUpdater(User.class, String.class,"name" );
nameUp.compareAndSet(useru, "dd", "ddd");
System.out.println(useru.getName());
/*AtomicReferenceFieldUpdater初始化要求传入三个参数：
字段所属的对象Class，字段Class，字段名。
基于反射。要求字段必须是volatile修饰，并且不能是private*/

//AtomicMarkableReference示例代码：
AtomicMarkableReference<User> amuser = 
new AtomicMarkableReference<AtomicTest.User>(user, false);
amuser.set(useru, true);
System.out.println(amuser.getReference().getName());
/*AtomicMarkableReference和AtomicReference相比增加了个boolean类型的标记位。*/

原子更新字段类

如果需原子地更新某个类里的某个字段时，就需要使用原子更新字段类，Atomic包提供了以下3个类进行原子字段更新。

• AtomicIntegerFieldUpdater：原子更新整型的字段的更新器。
• AtomicLongFieldUpdater：原子更新长整型字段的更新器。
• AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于原子的更新数据和数据的版本号，可以解决使用CAS进行原子更新时可能出现的ABA问题。

要想原子地更新字段类需要两步。第一步，因为原子更新字段类都是抽象类，每次使用的时候必须使用静态方法newUpdater()创建一个更新器，并且需要设置想要更新的类和属性。第二步，更新类的字段（属性）必须使用public volatile修饰符。

为了避免CAS过程中的ABA问题，并发包提供了两个类：AtomicStampedReference和AtomicMarkableReference。前者相当于一个（引用，integer）的二元组，后者相当于一个（引用，boolean）的二元组。
AtomicStampedReference可用来作为带版本号的原子引用，每次同时更新值和版本号，这样每次更新前比较值和版本号就可判断该变量是否被修改过甚至获取改动的次数；而如果不关心改动的次数只关心是否发生了改动，就可以使用AtomicMarkableReference，它在保存值之外还保存了一个标志位，初始可设为false，发生更新就设为true，从而可通过这个标志位判断该变量是否被修改过。

注:ABA问题是指在CAS操作过程中，假设我们想要把目标值由1改为2，一般过程是检测目标值是否为1，如果为1就将其设置为2。但可能在检测之前目标值变成了3，然后又变成了1，检测过程并不能察觉到这种变化。这一般不会有什么影响，但在某些情况下也可能会是一个问题。

以AtomicIntegerFieldUpdater为例：

结果：

悲观锁和乐观锁

悲观锁

总是假设最坏的情况，每次去拿数据的时候都认为其他并发线程会修改，所以每次在拿数据的时候都会上锁，这样其他线程想拿这个数据就会阻塞直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中 synchronized 和 ReentrantLock 等独占锁就是悲观锁思想的实现。

乐观锁

顾名思义，就是很乐观，每次去拿数据的时候都认为其他并发线程不会修改，所以不会上锁，只是在更新的时候会判断在此期间其他线程有没有去更新该数据，可以使用版本号机制和CAS算法实现，如果有线程修改过该数据，更新失败，重试直到成功。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

补充见：面试必备之乐观锁与悲观锁