一、同步容器类
同步容器类包括Vector和Hashtable，二者之外还包括在JDK1.2中添加的一些功能类似的类，就是那些以Collection.synchronizedXxxx等工厂方法创建的同步的封装器类。这些类实现线程安全的方式是：将他们的状态封装起来，并对每个公有方法都进行方法同步，使得每次只有一个线程能访问容器的状态。
1.1同步容器类的问题
同步容器类都是线程安全地，但是在某些情况下可能需要额外的客户端加锁来保护复合操作。容器的复合操作包括：迭代、跳转（根据指定顺序找到当前元素的下一个元素）、条件运算（若没有则添加）。在同步容器类中，这些符合操作在没有客户端枷锁的情况下仍然是线程安全地，但当其他线程并发地修改容器时，它们可能会出现意料之外的行为。
举个例子：Vector中的getLast（9）和deleteLast（9），他们都会先获得数组大小，然后通过结果来获取或删除某个元素：
A： size（10） —- get（9）—–出错
B： size（10）—remove（9）
看到了吧，为了避免上面的问题，我们的同步容器类要遵守同步策略，即支持客户端加锁，因此可能会创建一些新的操作，只要我们知道应该使用哪一个锁，那么这些新操作就与容器的其他操作一样是原子操作。
1.2迭代器与ConcurrentModificationException
上图中的针对关于复合操作中，另外有线程修改的问题，我们的迭代器碰见这种问题的时候，会抛出一个ConcurrentModificationException异常。
迭代器采用的方式是，将计数器的变化和容器关联起来，如果在迭代器期间计数器被修改，那么hasNext或next将抛出ConcurrentModificationException异常。和上面的迭代Vector一样，要想避免这种问题，我们就要在迭代过程中持有容器的锁。
这是我们平常能看到的，我们应该记住在所有对共享容器进行迭代的地方都需要加锁。实际情况中，更复杂一些，因为在某些情况下，调用某个方法，这个方法内部，自己其实实现了迭代，但是我们看不见。例如toString方法、hashCode方法、equals方法等。如果我们用synchronizedXxxx来包装原本的集合，就不会有这些问题，不过会付出很大的代价（串行化）。
二、并发容器
通过并发容器来代替同步容器，可以极大地提高伸缩性并降低风险
同步容器能将对容器的所有访问都串行化，但是这将付出极大的代价，严重降低并发行。
2.1ConcurrentHashMap介绍
同步容器是每个操作都持有那个锁，但是ConcurrentHashMap的原理是锁分段技术：ConcurrentHashMap所使用的锁分段技术，首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。
1ConcurrentHashMap和其他并发容器一起增强了同步容器类：它们提供的迭代器不会抛出ConcurrentMoidficationException，因此不用在迭代中对容器加锁，但是他并没有避免我们这个问题，他的策略是，所有的迭代器返回的数据具有弱一致性。就是说，这样他可以容忍并发地修改，当创建迭代器时候会遍历已有的元素，并可以（但是不保证）在迭代器被构造后将修改操作反映给容器。
记住一些常用的API：
仅当K没有对应映射值时才插入：
V putIfAbsent(K key,V value)
仅当K被映射到V时才移除：
boolean remove (K key,V value)
仅当K被映射到就vaule时候才替换成新值
boolean replace(K key,V oldValue,V newValue)
仅当K被映射到某个值时才替换为新值
V replace (K key,V newValue);
2.2CopyOnWriteArrayList
CopyOnWriteArrayList用于替代同步List，他有更好的并发性能，在迭代期间不需要对容器进行加锁。
他的做法是“写入时复制”，只要正确的发布一个事实不可变的对象，那么在访问该对象时就不需要进一步的同步。就是说在每次修改的时候，都会创建并重新发布一个新的容器副本，从而实现可变性。
2.3BlockingQueue
我们还可以用阻塞对联来模拟生产者和消费者的模式，但是当一个对象既可以是生产者，又可以使消费者的时候，我们应该使用双端队列Deque来完成任务（工作密取）。
在构建高可靠的应用程序时，有界队列是一种强大的资源管理工具：它们能一直并防止产生过多的工作项，使应用程序在负荷郭在的情况下变得更加健壮。
三、同步工具类
3.1闭锁
避免使用忙等，我们使用了CountDowmLatch 实现了需求。下面具体介绍一下这个：
Latch闭锁的意思，是一种同步的工具类。类似于一扇门：在闭锁到达结束状态之前，这扇门一直是关闭着的，不允许任何线程通过，当到达结束状态时，这扇门会打开并允许所有的线程通过。且当门打开了，就永远保持打开状态。
作用：可以用来确保某些活动直到其他活动都完成后才继续执行。
使用场景：
1、例如我们上例中所有人都到达饭店然后吃饭；
2、某个操作需要的资源初始化完毕
3、某个服务依赖的线程全部开启等等…
CountDowmLatch是一种灵活的闭锁实现，包含一个计数器，该计算器初始化为一个正数，表示需要等待事件的数量。countDown方法递减计数器，表示有一个事件发生，而await方法等待计数器到达0，表示所有需要等待的事情都已经完成。
private static CountDownLatch latch = new CountDownLatch(3);
public static void main(String[] args) throws InterruptedException
{
new Thread()
{
public void run()
{
fatherToRes();
latch.countDown();
};
}.start();
new Thread()
{
public void run()
{
motherToRes();
latch.countDown();
};
}.start();
new Thread()
{
public void run()
{
meToRes();
latch.countDown();
};
}.start();
latch.await();
togetherToEat();
} 3.2FutureTask
FutureTask也可以用作闭锁。FutureTsak表示的计算是通过Callable来实现的，相当于一种可生成结果的Runnable，并且可以处于三种状态：等待运行、正在运行、运行完成。
Future.get方法很关键，常用。如果任务已经完成，那么get就会返回结果，佛则get将组合直到任务进入完成状态，然后返回结果。FutureTsk将计算结果从执行计算的线程传递到获取这个结果的线程。
FutureTask可用于异步获取执行结果或取消执行任务的场景。通过传入Runnable或者Callable的任务给FutureTask，直接调用其run方法或者放入线程池执行，之后可以在外部通过FutureTask的get方法异步获取执行结果，因此，FutureTask非常适合用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。另外，FutureTask还可以确保即使调用了多次run方法，它都只会执行一次Runnable或者Callable任务，或者通过cancel取消FutureTask的执行等。
public class FutureTest1 {
public static void main(String[] args) {
Task task = new Task();// 新建异步任务
FutureTask<Integer> future = new FutureTask<Integer>(task) {
// 异步任务执行完成，回调
@Override
protected void done() {
try {
System.out.println("future.done():" + get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
};
// 创建线程池（使用了预定义的配置）
ExecutorService executor = Executors.newCachedThreadPool();
executor.execute(future);
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
// 可以取消异步任务
// future.cancel(true);
try {
// 阻塞，等待异步任务执行完毕-获取异步任务的返回值
System.out.println("future.get():" + future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
// 异步任务
static class Task implements Callable<Integer> {
// 返回异步任务的执行结果
@Override
public Integer call() throws Exception {
int i = 0;
for (; i < 10; i++) {
try {
System.out.println(Thread.currentThread().getName() + "_"
+ i);
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return i;
}
}
}3.3信号量
Semaphore，计数信号量，可以用于实现资源池，例如数据库连接池。
Semaphore使用时需要先构建一个参数来指定共享资源的数量，Semaphore构造完成后即是获取Semaphore、共享资源使用完毕后释放Semaphore。
Semaphore semaphore = new Semaphore(10,true);
semaphore.acquire();
//do something here
semaphore.release(); 3.4栅栏
栅栏类似闭锁，它能阻塞一组线程知道某个事件发生。栅栏和闭锁的关键区别在于，所有线程必须同时到达栅栏位置，才能继续执行。闭锁用于等待时间，而栅栏用于等待线程。
示例：简单模拟一下对战平台中玩家需要完全准备好了,才能进入游戏的场景。
public class BarrierDemo {
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(5);
final CyclicBarrier barrier = new CyclicBarrier(5);
for (int i = 0; i < 5; i++) {
service.execute(new Player("玩家" + i, barrier));
}
service.shutdown();
}
}public class Player implements Runnable {
private final String name;
private final CyclicBarrier barrier;
public Player(String name, CyclicBarrier barrier) {
this.name = name;
this.barrier = barrier;
}
public void run() {
try {
TimeUnit.SECONDS.sleep(1 + (new Random().nextInt(3)));
System.out.println(name + "已准备,等待其他玩家准备...");
barrier.await();
TimeUnit.SECONDS.sleep(1 + (new Random().nextInt(3)));
System.out.println(name + "已加入游戏");
} catch (InterruptedException e) {
System.out.println(name + "离开游戏");
} catch (BrokenBarrierException e) {
System.out.println(name + "离开游戏");
}
}
}玩家0已准备,等待其他玩家准备...
玩家2已准备,等待其他玩家准备...
玩家1已准备,等待其他玩家准备...
玩家4已准备,等待其他玩家准备...
玩家3已准备,等待其他玩家准备...
玩家4已加入游戏
玩家1已加入游戏
玩家0已加入游戏
玩家3已加入游戏
玩家2已加入游戏