辅助类
CountDownLatch
减法计数器,位于 java.util.concurrent 包下,我们看一下关于它的定义。
主要方法有:
首先我们看一个简单的案例:
public class CountDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(6);
for (int i = 0; i < 6; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"get out");
countDownLatch.countDown();//计数器减1
},String.valueOf(i)).start();
}
//计算器归零,await被唤醒
countDownLatch.await();//等待计数器归零,才向下继续执行
System.out.println("end");
}
}
执行结果为:
0get out
1get out
2get out
3get out
5get out
4get out
end
来个复杂点的,比如说有这样一个场景:一个大巴司机来接送一群工人去工作,只有当司机到了,工人们才可以出发准备去工作;同样的,只有等工人们都完成工作之后,司机才能接他们回去。转换为代码设计:
使用两倒计时锁:
- 第一个是一个开始信号,防止任何工人进入,直到司机准备好才能进入;
- 第二个是一个完成信号,允许司机等待,直到所有的工人已经完成。
public class DriverTest {
static final int N = 10;
public static void main(String[] args) throws InterruptedException {
CountDownLatch startSignal = new CountDownLatch(1);
CountDownLatch doneSignal = new CountDownLatch(N);
for (int i = 0; i < N; ++i){
new Thread(new Worker(startSignal, doneSignal),"工人"+(i+1)+"号").start();
}
doSomethingElse1(); // don't let run yet
startSignal.countDown(); // let all threads proceed
doneSignal.await(); // wait for all to finish
doSomethingElse2();
}
public static void doSomethingElse1() throws InterruptedException {
TimeUnit.SECONDS.sleep(2);
System.out.println("司机来送工人去工作");
}
public static void doSomethingElse2() throws InterruptedException {
TimeUnit.SECONDS.sleep(1);
System.out.println("司机来接工人回去");
}
}
class Worker implements Runnable {
private final CountDownLatch startSignal;
private final CountDownLatch doneSignal;
Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
this.startSignal = startSignal;
this.doneSignal = doneSignal;
}
public void run() {
try {
startSignal.await();
doWork();
doneSignal.countDown();
} catch (InterruptedException ex) {} // return;
}
void doWork() throws InterruptedException {
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName()+"开始工作......");
}
}
执行结果为:
司机来送工人去工作
工人4号开始工作......
工人6号开始工作......
工人8号开始工作......
工人3号开始工作......
工人7号开始工作......
工人9号开始工作......
工人2号开始工作......
工人1号开始工作......
工人10号开始工作......
工人5号开始工作......
司机来接工人回去
CyclicBarrier
加法计数器,与 CountDownLatch 作用相反。
主要方法有:
public class CyclicBarrierDemo {
public static void main(String[] args) {
CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
System.out.println("召唤神龙");
});
for (int i = 0; i < 7; i++) {
final int temp = i+1;
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"收集"+temp+"个龙珠");
try {
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
}
}
}
Semaphore
计数器信号量。
以下是个抢车位的案例,假设有6个人去抢3个车位,谁先抢到谁占用,直到离开下一个人再去抢用。
public class SemaphoreDemo {
public static void main(String[] args) {
Semaphore semaphore = new Semaphore(3);
for (int i = 0; i < 6; i++) {
new Thread(()->{
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName()+"抢到了车位!");
TimeUnit.SECONDS.sleep(2);
System.out.println(Thread.currentThread().getName()+"离开了车位!");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
semaphore.release();
}
}).start();
}
}
}
semaphore.acquire()
方法表示从该信号量获取许可证,假设已经满了,则等待,直到有许可证被释放。
semaphore.release()
方法表示释放许可证,将其返回到信号量。同时唤醒那些还在等待的线程。
作用:多个共享资源互斥的使用,并发限流,控制最大线程数。
阻塞队列
BlockingQueue
概念
以下是官方文档对于阻塞队列的介绍:
我们来看一下 BlockingQueue 的接口图:
- ArrayBlockingQueue: 由 数 组 结 构 组 成 的 有 界 阻 塞 队 列 。
- LinkedBlockingQueue:由链表结构组成的有界(默认值为:integer.MAX_VALUE)阻塞队列。
- PriorityBlockingQueue:支持优先级排序的无界阻塞队列
- DelayQueue:使用优先级队列实现的延迟无界阻塞队列。
- SynchronousQueue:不存储元素的阻塞队列,也即单个元素的队列。
- LinkedTransferQueue:由链表组成的无界阻塞队列。
- LinkedBlockingDeque:由链表组成的双向阻塞队列。
阻塞队列是一个队列,在数据结构中起的作用如下图:
当队列是空的,从队列中获取元素的操作将会被阻塞。直到其他线程往空的队列插入新的元素。
当队列是满的,从队列中添加元素的操作将会被阻塞。直到其他线程从队列中移除一个或多个元素或者完全清空,使队列变得空闲起来并后续新增。
作用
在多线程领域:所谓阻塞,在某些情况下会挂起线程(即阻塞),一旦条件满足,被挂起的线程又会自动被唤起。
为什么需要 BlockingQueue?
好处是我们不需要关心什么时候需要阻塞线程,什么时候需要唤醒线程,因为这一切BlockingQueue 都给你一手包办了。
在 concurrent 包发布以前,在多线程环境下,我们每个程序员都必须自己去控制这些细节,尤其还要兼顾效率和线程安全,而这会给我们的程序带来不小的复杂度。
核心方法
常用 API
对上述内容的详细解释如下:
我们对上述内容进行代码展示,首先是抛出异常情况下的插入和移除方法使用:
public class BlockingQueueTest {
public static void main(String[] args) throws InterruptedException {
ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);
//java.lang.IllegalStateException: Queue full
System.out.println(blockingQueue.add("A"));
System.out.println(blockingQueue.add("B"));
System.out.println(blockingQueue.add("C"));
// System.out.println(blockingQueue.add("D")); //此时队列已满,报错 java.lang.IllegalStateException: Queue full
System.out.println(blockingQueue.remove());
System.out.println(blockingQueue.remove());
System.out.println(blockingQueue.remove());
// System.out.println(blockingQueue.remove()); //队列已空,报错java.util.NoSuchElementException
}
}
返回特殊值
public class BlockingQueueTest {
public static void main(String[] args) throws InterruptedException {
ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);
System.out.println(blockingQueue.offer("A"));
System.out.println(blockingQueue.offer("B"));
System.out.println(blockingQueue.offer("C"));
System.out.println(blockingQueue.offer("D"));//队列已满,插入失败,返回false
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());//队列已空,返回null
}
}
一直阻塞
public class BlockingQueueTest {
public static void main(String[] args) throws InterruptedException {
ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);
blockingQueue.put("A");
blockingQueue.put("B");
blockingQueue.put("C");
// blockingQueue.put("D"); //队列已满,会一直阻塞下去
System.out.println(blockingQueue.take());
System.out.println(blockingQueue.take());
System.out.println(blockingQueue.take());//返回正常值
// System.out.println(blockingQueue.take());//队列已空,会一直阻塞
}
}
超时等待
public class BlockingQueueTest {
public static void main(String[] args) throws InterruptedException {
ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);
blockingQueue.offer("A");
blockingQueue.offer("B");
blockingQueue.offer("C");
// blockingQueue.offer("D",2, TimeUnit.SECONDS);//队列已满,则等待2s后结束
blockingQueue.poll();
blockingQueue.poll();
blockingQueue.poll();
// blockingQueue.poll(3,TimeUnit.SECONDS); //队列已空,等待3s后结束
}
}
SynchronousQueue
同步队列 SynchronousQueue 没有容量。
与其他的 BlockingQueue 不同,SynchronousQueue 是一个不存储元素的 BlockingQueue 。每一个 put 操作必须要等待一个 take 操作,否则不能继续添加元素,反之亦然。
public class SynchronousQueueDemo {
public static void main(String[] args) {
BlockingQueue<String> blockingQueue = new SynchronousQueue<>();//同步队列
new Thread(()->{
try {
System.out.println(Thread.currentThread().getName()+"put 1");
blockingQueue.put("1");
System.out.println(Thread.currentThread().getName()+"put 2");
blockingQueue.put("2");
System.out.println(Thread.currentThread().getName()+"put 3");
blockingQueue.put("3");
} catch (InterruptedException e) {
e.printStackTrace();
}
},"T1").start();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName()+"get data:"+blockingQueue.take());
TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName()+"get data:"+blockingQueue.take());
TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName()+"get data:"+blockingQueue.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
},"T2").start();
}
}
执行结果为:
T1put 1
T2get data:1
T1put 2
T2get data:2
T1put 3
T2get data:3