JUC

首先来说说synchronized的有什么缺点。

它非常的死板。要么获取锁，要么等待锁，而且我们无法知晓此时这个锁有没有被人拿到，也不知道某个线程是否是上锁状态。

只有悲观锁、排他锁，没有乐观锁、共享锁。有些资源允许很多线程去读，但是只允许一个线程写，这样的锁叫做共享锁。悲观锁就是做某个操作必须要拿到一个锁。乐观锁就是先去把一个任务做完，但由于多个线程竞争这个操作没有正确完成，那就重新做一遍，直到正确为止。

性能相对较差

java.util.concurrent简称JUC，是Java的并发工具包，解决了上述的一些问题。

Lock / Condition

Lock提供了一个更加复杂的锁机制。它允许更加灵活的结构，支持不同的方法，支持相关的Condition操作。

同一个锁可以有多个条件。

读写分离。Lock的实现中有读锁WriteLock和写锁ReadLock。

tryLock方法。如果该锁可用立刻返回true，不可用则立刻返回false。

可以方便的实现更加灵活的优先级/公平性。公平性指的是，假如有多个线程竞争一个锁的话，我以什么顺序给它们。非公平锁，主要靠操作系统的调度。Lock的实现中有可重入锁ReentrantLock(默认是非公平锁，可以传一个参数让它变成公平锁)。

Conditon把Object的monitor方法(wait，notify，notifyAll)拆出来成了独立的对象，使得支持多个等待集合。

CountDownLatch

倒数闭锁。

用于协调一组线程的工作。

它的API简单暴力countDown()，await()。以下是一个使用例子：

public class Main {

public static void main(String[] args) throws InterruptedException {

final CountDownLatch countDownLatch = new CountDownLatch(10);

for (int i = 0; i < 10; i++) {

int finalI = i;

new Thread(() -> {

int second = new Random().nextInt(10);

try {

Thread.sleep(second * 1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("线程" + finalI + "干完活了");

countDownLatch.countDown();

}).start();

}

countDownLatch.await();

System.out.println("老板发话了，所有人干完活了！");

}

}

CyclicBarrier

循环的屏障

等所有线程执行完了，才继续：

public class Main {

public static void main(String[] args) throws InterruptedException {

final CyclicBarrier cyclicBarrier = new CyclicBarrier(5);

for (int i = 0; i < 5; i++) {

int finalI = i;

new Thread(() -> {

int second = new Random().nextInt(10);

try {

Thread.sleep(second * 1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("线程" + finalI + "干完活了");

try {

cyclicBarrier.await();

} catch (InterruptedException | BrokenBarrierException e) {

e.printStackTrace();

}

System.out.println("所有线程都执行完了，大家一起说！");

}).start();

}

}

}

Semaphore

信号量

信号量的获取和释放

BlockingQueue & BlockingDeque

传统的集合框架的操作要么正常返回，要么丢出异常，BlockingQueue/BlockingDeque提供⼀种「等待」的可能。

API: 阻塞操作：put/take。

先声明容量大小，如果put超过容量，则会等待另一个线程take。

BlockingQueue先进先出。BlockingDeque头尾都能进出，更加灵活。

Future & ExecutorService

Future代表⼀个「未来才会发⽣的事情」。

Future本身是⽴即返回的。

get()会阻塞并返回执⾏结果，并抛出可能的异常。异常的抛出一般只会在当前线程，而get可以把其他线程的异常转移到当前线程抛出。

线程池的参数。建议看ExecutorService的一个实现：ThreadPoolExecutor文档。

* Creates a new {@code ThreadPoolExecutor} with the given initial

* parameters and default rejected execution handler.

*

-----* 核心线程的数量，哪怕它们闲下来，也不会被丢弃。

* @param corePoolSize the number of threads to keep in the pool, even

* if they are idle, unless {@code allowCoreThreadTimeOut} is set

-----* 最多可以开这么多的线程工作。

* @param maximumPoolSize the maximum number of threads to allow in the

* poo

-----* 下面两个是联合使用的，非核心线程空闲多久会被杀死。

* @param keepAliveTime when the number of threads is greater than

* the core, this is the maximum time that excess idle threads

* will wait for new tasks before terminating.

* @param unit the time unit for the {@code keepAliveTime} argument

-----* 保存那些还没被执行的任务。

* @param workQueue the queue to use for holding tasks before they are

* executed. This queue will hold only the {@code Runnable}

* tasks submitted by the {@code execute} method.

-----* 每当你需要一个新的线程的时候，用它来创建。

* @param threadFactory the factory to use when the executor

* creates a new thread

-----* 假如任务来的太快，把任务队列撑满了，要采取何种策略？

-----* AbortPolicy丢弃策略、CallerRunsPolicy让调用者执行

-----* DiscardOldestPolicy丢弃最老的一个任务、DiscardOldestPolicy丢弃最新的一个任务。

* @param handler the handler to use when execution is blocked

* because the thread bounds and queue capacities are reached

还可以举一个通俗易懂的例子，假如你是一个老板，有如下的参数解释：

corePoolSize 核⼼员⼯数量

maximumPoolSize 最⼤招募的员⼯数量

keepAliveTime/unit 员⼯闲下来多久之后炒掉他们

workQueue 订单队列

threadFactory 造⼈的⼯⼚

handler 订单实在太多的处理策略

Java 默认实现的线程池，使用Executors.xxx创建一个线程池，且这些方法大多都返回一个ThreadPoolExecutor，如下所示：

public static ExecutorService newxxxThreadPool(xxx) {

return new ThreadPoolExecutor(六个参数);

}