三个并发编程工具包java.util.concurent/locks/atomic的概念厘清

Java提供了三个并发编程功能包，它们是：
[list]
[*]java.util.concurent
[*]java.util.concurent.locks
[*]java.util.concurent.atomic
[/list]

本文意在厘清这三个包的概念结构，关于具体功能的实现，将另文详记。

[color=blue][size=xx-large]1. Overview[/size][/color]
java.util.concurent/locks/atomic三个包主要提供了以下三块功能：
[table]
|功能|涉及包
|一组线程安全数据结构|concurrent+atomic
|一组比synchronized关键子功能更丰富的同步工具|concurrent+locks
|一套线程池实现框架|concurrent
[/table]
本文接下来，按照功能整理这些包的逻辑结构。

[color=blue][size=xx-large]2 线程安全的数据结构[/size][/color]
[color=blue][size=x-large]2.1 java.util.concurent.atomic包[/size][/color]
首先，java.util.concurent.atomic包的所有类，都是用于提供一组不需要进行线程同步，可以安全的进行并发操作的变量类，罗列如下：
[list]
[*]AtomicBoolean
[*]AtomicInteger
[*]AtomicIntegerArray
[*]AtomicIntegerFieldUpdater
[*]AtomicLong
[*]AtomicLongArray
[*]AtomicLongFieldUpdater
[*]AtomicMarkableReference
[*]AtomicReference
[*]AtomicReferenceArray
[*]AtomicReferenceFieldUpdater
[*]AtomicStampedReference
[*]DoubleAccumulator
[*]DoubleAdder
[*]LongAccumulator
[*]LongAdder
[/list]

[color=blue][size=x-large]2.2 java.util.concurent提供的复杂线程安全数据结构[/size][/color]
在java.util.concurent.atomic包的基础上，java.util.concurent包实现了一组复杂的线程安全数据结构。可以分为以下几个小组：
java.util.AbstractQueue的子类：

java.util.AbstractQueue<E> (implements java.util.Queue<E>)
    java.util.concurrent.ArrayBlockingQueue<E> 
    java.util.concurrent.ConcurrentLinkedQueue<E> 
    java.util.concurrent.DelayQueue<E>
    java.util.concurrent.LinkedBlockingDeque<E>
    java.util.concurrent.LinkedBlockingQueue<E>
    java.util.concurrent.LinkedTransferQueue<E>
    java.util.concurrent.PriorityBlockingQueue<E>
    java.util.concurrent.SynchronousQueue<E>

java.util.AbstractSet的子类：

java.util.AbstractSet<E>
    java.util.concurrent.ConcurrentSkipListSet<E>
    java.util.concurrent.CopyOnWriteArraySet<E>

java.util.AbstractCollection的子类：

java.util.AbstractCollection<E>
    java.util.concurrent.ConcurrentLinkedDeque<E>
    java.util.concurrent.ConcurrentHashMap.KeySetView<K,V>
    java.util.concurrent.CopyOnWriteArrayList<E> 

java.util.AbstractMap的子类：

java.util.AbstractMap<K,V>
    java.util.concurrent.ConcurrentHashMap<K,V>
    java.util.concurrent.ConcurrentSkipListMap<K,V>

[color=blue][size=xx-large]3 功能丰富的同步工具[/size][/color]
[color=blue][size=x-large]3.1 Overview[/size][/color]
[img]http://dl.iteye.com/upload/picture/pic/131935/e8a7a810-28b2-3719-a88b-0c959ac978e1.png[/img]
[color=blue][size=x-large]3.2 java.util.concurrent.locks包[/size][/color]
[color=blue][size=large]3.1.1 Synchronizer[/size][/color]
java.util.concurrent.locks包中最核心类是AbstractQueuedSynchronizer，它定义了实现线程安全数据结构的最基本的操作，主要是以下几类：
[list]
[*]acquire
[*]release
[*]compareAndSetState
[*]waitting queue操作
[/list]
AbstractOwnableSynchronizer是其父类，只定义了两个waitting queue操作：getExclusiveOwnerThread()和setExclusiveOwnerThread。

AbstractQueuedLongSynchronizer是AbstractQueuedSynchronizer的兄弟类，与AbstractQueuedSynchronizer的唯一区别在于其状态用long型数据表示。

这三个Synchronizer的底层实现不是依赖synchronized的，而是依赖[url=http://java.dzone.com/articles/understanding-sunmiscunsafe?page=0,0]Unsafe[/url]。

[color=blue][size=large]3.1.2 Lock[/size][/color]
在Synchronizer的基础上，java.util.concurrent.locks包实现了锁的概念，包括Lock接口的实现类和ReadWriteLock接口的实现类。

[color=blue][size=large]3.1.3 LockSupport[/size][/color]
LockSupport提供了并发编程中的park语义，它替代了已经deprecated的Thread.suspend()/resume()。具体原因：[url=http://docs.oracle.com/javase/8/docs/technotes/guides/concurrency/threadPrimitiveDeprecation.html]Java Thread Primitive Deprecation[/url]

[color=blue][size=x-large]3.3 功能更强大的同步工具[/size][/color]
在java.util.concurrent.locks包的基础上，java.util.concurrent实现了一些列功能更为复杂的同步工具类：
[list]
[*]java.util.concurrent.CountDownLatch
[*]java.util.concurrent.CyclicBarrier
[*]java.util.concurrent.Exchanger<V>
[*]java.util.concurrent.Semaphore
[*]java.util.concurrent.Phaser
[/list]

[color=blue][size=xx-large]4 线程池框架[/size][/color]
[color=blue][size=x-large]4.1 ExecutorService[/size][/color]
线程池的主体功能有两种实现，第一种由实现ExecutorService接口的一系列类来实现：

java.util.concurrent.AbstractExecutorService
    java.util.concurrent.ForkJoinPool
    java.util.concurrent.ThreadPoolExecutor 
    java.util.concurrent.ScheduledThreadPoolExecutor

一个使用Executor Serivce是简单例子如下所示：

ExecutorService executorService = Executors.newFixedThreadPool(10);
executorService.execute(new Runnable() 
{
    public void run() 
    {
        System.out.println("Asynchronous task");
    }
});
executorService.shutdown();

第二种由实现CompletionService接口的类实现，这样的类只有一个：java.util.concurrent.ExecutorCompletionService。A service that decouples the production of new asynchronous tasks from the consumption of the results of completed tasks. Producers submit tasks for execution. Consumers take completed tasks and process their results in the order they complete.

[color=blue][size=x-large]4.2 Future[/size][/color]
一系列实现Future接口的类实现了异步编程中的[i]Promise[/i]语义：

java.util.concurrent.CompletableFuture<T>
java.util.concurrent.ForkJoinTask<V>
    java.util.concurrent.CountedCompleter<T>
    java.util.concurrent.RecursiveAction
    java.util.concurrent.RecursiveTask<V>
java.util.concurrent.FutureTask<V>

调用可能有较长时间阻塞/等待的方法时，可以先返回一个轻量级的Future对象，方法执行的真正结果可以通过调用Future.get()获取。

[color=blue][size=xx-large]5 其他相关类的说明[/size][/color]
[list]
[*][b]java.util.concurrent.Executors:[/b]Executor, ExecutorService, ScheduledExecutorService, ThreadFactory,Callable 等的工厂/工具类。
[*][b]java.util.concurrent.ThreadLocalRandom:[/b]java.util.Random类的子类，A random number generator isolated to the current thread.
[*][b]java.util.concurrent.ForkJoinWorkerThread:[/b]专门用于执行 ForkJoinTasks的Thread子类
[/list]