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(六个参数);
}
网友评论