Java中的原子操作类 / 并发工具类（Java并发编程的艺术笔记）
等待多线程完成的CountDownLatch
CountDownLatch允许一个或多个线程等待其他线程完成操作，简单使用如下。
public class Test {
public static void main(String[] args) throws InterruptedException{
CountDownLatch clock = new CountDownLatch(2);
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("1");
clock.countDown();
System.out.println("2");
clock.countDown();
}
}).start();
clock.await();
System.out.println("3");
}
}如果想要等待N个点完成，则在构造方法传入N。当调用CountDownLatch的countDown方法时，N就会减1，CountDownLatch的await方法 会阻塞当前线程，直到N变成零。此处的N可以是1个线程里的N个步骤或N个线程。若是用在多线程，只需要把这个CountDownLatch引用传递给线程里。
若等待其他线程很久，不希望让主线程一直等待，可以使用带指定时间的await（long time，TimeUnit unit）方法。
同步屏障CyclicBarrier
当一组线程到达一个屏障时被阻塞，直至最后一个线程到达屏障时，屏障才会打开，被拦截的线程才能继续允许。
它的构造方法是CyclicBarrier（int parties），其参数表示屏障拦截的线程数 量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。
此外，它还提供一个更高级的构造函数CyclicBarrier（int parties，Runnable barrierAction），用于在线程到达屏障时，优先执行barrierAction，方便处理更复杂的业务场景。
CyclicBarrier可用于多线程计算数据，最后合并计算结果的场景。如下所示，使用线程池创建4个线程，分别模拟计算每个sheet里的数据，再由BankWaterService线程汇总4个sheet计算出的结果
public class Test {
public static class BankWaterService implements Runnable {
// 创建4个屏障，处理完后执行当前类的run方法
private CyclicBarrier barrier = new CyclicBarrier(4, this);
// 启动一个用于4个线程的线程池
private Executor executor = Executors.newFixedThreadPool(4);
private ConcurrentHashMap<String, Integer> sheetCount = new ConcurrentHashMap<>();
private void count() {
for(int i = 0; i < 4; i++) {
executor.execute(new Runnable() {
@Override
public void run() {
// 计算当前线程的数据，此处将结果省略为1
sheetCount.put(Thread.currentThread().getName(), 1);
try {
barrier.await();
}catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
}
});
}
}
@Override
public void run() { // 计算每个线程计算出的结果
int result = 0;
for(Map.Entry sheet : sheetCount.entrySet()) {
result += (int)(sheet.getValue());
}
sheetCount.put("result", result);
System.out.println(result);
}
}
public static void main(String[] args) throws InterruptedException{
BankWaterService bankWaterService = new BankWaterService();
bankWaterService.count();
}
}
CyclicBarrier和CountDownLatch的区别
CountDownLatch的计数器只能使用一次，而CyclicBarrier的计数器可以使用reset()方法重 置。所以CyclicBarrier能处理更为复杂的业务场景。例如，如果计算发生错误，可以重置计数 器，并让线程重新执行一次。
CyclicBarrier还提供其他有用的方法，比如getNumberWaiting方法可以获得Cyclic-Barrier 阻塞的线程数量。isBroken()方法用来了解阻塞的线程是否被中断。
控制并发线程数的Semaphore
Semaphore（信号量）是用来控制同时访问特定资源的线程数量。
Semaphore可以用于做流量控制，特别是公用资源有限的应用场景，比如数据库连接假 如有一个需求，要读取几万个文件的数据，因为都是IO密集型任务，我们可以启动几十个线程 并发地读取，但是如果读到内存后，还需要存储到数据库中，而数据库的连接数只有10个，这 时我们必须控制只有10个线程同时获取数据库连接保存数据，否则会报错无法获取数据库连接。
如下代码，虽然由30个线程在执行，但只允许10个并发执行。线程通过acquire()方法获取一个许可证，通过release()归还许可
public class Test {
public static void main(String[] args) throws InterruptedException{
int THREAD_COUNT = 30;
ExecutorService pool = Executors.newFixedThreadPool(THREAD_COUNT);
Semaphore s = new Semaphore(10);
for(int i = 0; i < THREAD_COUNT; i++) {
pool.execute(new Runnable() {
@Override
public void run() {
try {
s.acquire();
System.out.println("保存数据");
s.release();
}catch (InterruptedException e) {
}
}
});
}
pool.shutdown();
}
}
线程间交换数据的Exchanger
Exchanger用于进行线程间的数据交 换。它提供一个同步点，在这个同步点，两个线程可以交换彼此的数据。这两个线程通过 exchange方法交换数据，如果第一个线程先执行exchange()方法，它会一直等待第二个线程也 执行exchange方法，当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产 出来的数据传递给对方。
public class Test {
public static void main(String[] args) throws InterruptedException{
Exchanger<String> exc = new Exchanger<>();
ExecutorService pool = Executors.newFixedThreadPool(2);
pool.execute(new Runnable() {
@Override
public void run() {
try {
String A = "银行流水A";
exc.exchange(A);
}catch (InterruptedException e) { }
}
});
pool.execute(new Runnable() {
@Override
public void run() {
try {
String B = "银行流水B";
String A = exc.exchange("");
System.out.println("A数据：" + A );
}catch (InterruptedException e) { }
}
});
pool.shutdown();
}
}若两个线程有一个没有执行行exchange()方法，则会一直等待。若希望避免一直等待，可以使用exchange（V x，longtimeout，TimeUnit unit）设置最大等待时长。
原子操作类概述
java.util.concurrent.atomic包（简称Atomic包）中的原子操作类提供了一种线程安全的更新变量的方式，包里一共提供13个类，分别属于4中原子更新方式：原子更新基本类型，原子更新数组，原子更新引用和原子更新属性（字段）。
原子更新基本类型
- AtomicBoolean：原子更新布尔类型。
- AtomicInteger：原子更新整型。
- AtomicLong：原子更新长整型。
3个类提供的方法几乎一样，本节以AtomicInteger为例，它的常用方法如下：
- int addAndGet（int delta）：以原子方式将输入的数值与实例中的值（AtomicInteger里的 value）相加，并返回结果。
- ·boolean compareAndSet（int expect，int update）：如果输入的数值等于预期值，则以原子方 式将该值设置为输入的值。
- ·int getAndIncrement()：以原子方式将当前值加1，注意，这里返回的是自增前的值。
- ·int getAndSet（int newValue）：以原子方式设置为newValue的值，并返回旧值。
分析以一下getAndIncrement()如何实现原子操作。
public final int getAndIncrement() {
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return current;
}
}
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}源码中for循环体的第一步先取得AtomicInteger里存储的数值，第二步对AtomicInteger的当 前数值进行加1操作，关键的第三步调用compareAndSet方法来进行原子更新操作。
Atomic包只提供了3种基本类型的原子更新，但是Java的基本类型里还有char、float和double 等，那又如何原子的更新这些类型呢？
Atomic包里的类基本都是使用Unsafe 实现的，看一下Unsafe的源码，发现只提供了3种CAS方。，因此对于上述类型，它是先把Boolean转换成整 型，再使用compareAndSwapInt进行CAS，所以原子更新char、float和double变量也可以用类似的思路来实现。
/**
* 如果当前数值是expected，则原子的将Java变量更新成x
* @return 如果更新成功则返回true
*/
public final native boolean compareAndSwapObject(Object o,long offset,Object expected, Object x);
public final native boolean compareAndSwapInt(Object o, long offset,
int expected, int x);
public final native boolean compareAndSwapLong(Object o, long offset,
long expected, long x);
原子更新数组
通过原子的方式更新数组里的某个元素，Atomic包提供了以下4个类
- ·AtomicIntegerArray：原子更新整型数组里的元素。
- ·AtomicLongArray：原子更新长整型数组里的元素。
- ·AtomicReferenceArray：原子更新引用类型数组里的元素。
AtomicIntegerArray常用方法如下：
- ·int addAndGet（int i，int delta）：以原子方式将输入值与数组中索引i的元素相加。
- ·boolean compareAndSet（int i，int expect，int update）：如果当前值等于预期值，则以原子方式将数组位置i的元素设置成update值。
数组value通过构造方法传递进去，AtomicIntegerArray会将当前数组复制一份，所以当AtomicIntegerArray对内部的数组元素进行修改时，不会影响传入的数组。
原子更新引用类型
原子更新基本类型的AtomicInteger，只能更新一个变量，如果要原子更新多个变量，就需 要使用这个原子更新引用类型提供的类。Atomic包提供了以下3个类
- ·AtomicReference：原子更新引用类型。
- ·AtomicReferenceFieldUpdater：原子更新引用类型里的字段。
- ·AtomicMarkableReference：原子更新带有标记位的引用类型。可以原子更新一个布尔类 型的标记位和引用类型。构造方法是AtomicMarkableReference（V initialRef，boolean initialMark）。
AtomicReference的使用示例如下所示：
public class Test {
public static class User {
private String name;
private int agel
public User(String name, int agel) {
this.name = name;
this.agel = agel;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAgel() {
return agel;
}
public void setAgel(int agel) {
this.agel = agel;
}
}
public static void main(String[] args) throws Exception{
AtomicReference<User> userRef = new AtomicReference<>();
User user = new User("conman", 15);
userRef.set(user);
User updateUser = new User("new conman", 17);
userRef.compareAndSet(user, updateUser);
}
}
原子更新字段类
如果需原子地更新某个类里的某个字段时，就需要使用原子更新字段类，Atomic包提供 了以下3个类进行原子字段更新。 ·AtomicIntegerFieldUpdater：原子更新整型的字段的更新器。
·AtomicLongFieldUpdater：原子更新长整型字段的更新器。
·AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起 来，可用于原子的更新数据和数据的版本号，可以解决使用CAS进行原子更新时可能出现的 ABA问题。
以AstomicIntegerFieldUpdater为例，每次使用时都必须用静态方法newUpdater()创建一个更新器并且需要设置想要更新的类和属性。其次，更新类的字段（属性）必须使用public volatile修饰符。
public class Test {
public static class User {
private String name;
public volatile int age; // public volatile
public User(String name, int agel) {
this.name = name;
this.age = agel;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAgel() {
return age;
}
public void setAgel(int agel) {
this.age = agel;
}
}
public static void main(String[] args) throws Exception{
// 创建原子更新器，并设置需要更新的对象类和对象的属性
AtomicIntegerFieldUpdater<User> userFie = AtomicIntegerFieldUpdater.newUpdater(User.class,
"age");
User conan = new User("conan", 10);
// 增加1岁：输出的是旧值 10
System.out.println(userFie.getAndIncrement(conan));
// 输出新值 11
System.out.println(userFie.get(conan));
}
}