并发包(Concurrent包)中含有的类有哪些?
ConcurrentHashMap / CopyOnWriteArrayList
阻塞队列
同步辅助类
线程池相关的类
Lock接口
原子类
同步辅助类
1)CountDownLatch:闭锁
它就相当于一个计数器。用一个给定的数值初始化CountDownLatch,之后计数器就从这个值开始倒计数,知道计数值达到0。
CountDownLatch是通过"共享锁"实现的。在创建CountDownLatch时,会传递一个int类型参数,该参数是"锁计数器"的初始状态,表示该"共享锁"最多能被count个线程同时获取,这个值只能被设置一次,而且CountDownLatch没有提供任何机制去重新设置这个计数值。主线程必须在启动其他线程后立即调用await()方法。这样主线程的操作就会在这个方法上阻塞,直到其他线程完成各自的任务。当某线程调用该CountDownLatch对象的await()方法时,该线程会等待"共享锁"可用时,才能获取"共享锁"进而继续运行。而"共享锁"可用的条件,就是"锁计数器"的值为0!而"锁计数器"的初始值为count,每当一个线程调用该CountDownLatch对象的countDown()方法时,才将"锁计数器"-1;通过这种方式,必须有count个线程调用countDown()之后,"锁计数器"才为0,而前面提到的等待线程才能继续运行!
3个重要的函数:
//作用是让线程阻塞等待其他线程,直到CountDownLatch的计数值变为0,才继续执行之后的操作。
public void await() throws InterruptedException {};
//和await()类似,只不过等待⼀定的时间后count值还没变为0的话就会继续执⾏
public boolean await(long timeout, TimeUnit unit) throws InterruptedException
{}
//这个函数用来将CountDownLatch的计数值-1,如果技术达到0,则释放所有等待的线程。
public void countDown() {};
图示:
它的应用场景:
一个任务,它需要等待其他的一些任务都执行完毕之后它才能继续执行。
比如:开5个多线程去下载,当5个线程都执行完了才算下载成功。
对于倒计数器,一种典型的场景就是火箭发射,在火箭发射前,为了保证万无一失,往往还需要进行各项设备、仪器的检测。只有等到所有的检查完毕后,引擎才能点火。那么在检测环节当然是多个检测项可以同时进行的。代码实现:
public class CountDownLatchDemo implements Runnable{
static final CountDownLatch latch = new CountDownLatch(10);
static final CountDownLatchDemo demo = new CountDownLatchDemo();
@Override
public void run() {
//模拟检查任务
try {
Thread.sleep(new Random().nextInt(10) * 1000);
System.out.println("check complete");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
//计数减一
//放在finally避免任务执行过程出现异常,导致countDown()不能被执行
latch.countDown();
}
}
public static void main(String[] args) throws InterruptedException {
ExecutorService exec = Executors.newFixedThreadPool(10);
for (int i = 0; i < 10;i++){
exec.submit(demo);
}
//等待检查
latch.await();
//发射火箭
System.out.println("Fire!!!");
//关闭线程池
exec.shutdown();
}
}
上述代码中,我们先生成了一个CountDownLatch实例。计数数量为10,这表示需要有10个线程来完成任务,等待在CountDownLatch上的线程才能继续执行。latch.countDown();方法作用是通知CountDownLatch有一个线程已经准备完毕,倒计数器可以减一了。latch.await()方法要求主线程等待所有10个检查任务全部准备好才一起并行执行。
2)CyclicBarrier:循环栅栏
通过它可以实现让⼀组线程等待⾄某个状态之后再全部同时执⾏。叫做回环是因为当所有等待线程都被释放以后,CyclicBarrier可以被重⽤。我们暂且把这个状态就叫做barrier,当调⽤await()⽅法之后,线程就处于barrier了。
CyclicBarrier提供2个构造器:
public CyclicBarrier(int parties, Runnable barrierAction) {}
public CyclicBarrier(int parties) {}
参数parties指让多少个线程或者任务等待⾄barrier状态;参数barrierAction为当这些线程都达到 barrier状态时会执⾏的内容。
CyclicBarrier中最重要的⽅法就是await⽅法,它有2个重载版本:
public int await() throws InterruptedException, BrokenBarrierException { };
public int await(long timeout, TimeUnit unit) throws InterruptedException,BrokenBarrierException,TimeoutException { };
第⼀个版本⽐较常⽤,⽤来挂起当前线程,直⾄所有线程都到达barrier状态再同时执⾏后续任务;
第⼆个版本是让这些线程等待⾄⼀定的时间,如果还有线程没有到达barrier状态就直接让到达barrier 的线程执⾏后续任务。
await()函数每调用一次,计数器便会减少1(CyclicBarrier设置了初始值)。并阻塞住当前线程。当计数减至0时,阻塞解除,所有在此CyclicBarrier上面阻塞的线程开始运行。
图示:
代码示例:
public class CyclicBarrierDemo {
static class TaskThread extends Thread {
CyclicBarrier barrier;
public TaskThread(CyclicBarrier barrier) {
this.barrier = barrier;
}
@Override
public void run() {
try {
Thread.sleep(1000);
System.out.println(getName() + "到达栅栏 A");
barrier.await();
System.out.println(getName() + "冲破栅栏 A");
Thread.sleep(2000);
System.out.println(getName() + "到达栅栏 B");
barrier.await();
System.out.println(getName() + "冲破栅栏 B");
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
int threadNum = 5;
CyclicBarrier barrier = new CyclicBarrier(threadNum, new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "完成最后的任务");
}
});
for (int i = 0; i < threadNum; i++) {
new TaskThread(barrier).start();
}
}
}
从执行结果中可以看出,所有线程会等待全部线程到达栅栏之后才会继续执行,并且最后到达的线程会完成Runnable的任务。
CountDownLatch和CyclicBarrier的区别?
1)CountDownLatch的作用是允许1个线程等待其他线程执行完成之后,它才执行;而CyclicBarrier则是允许N个线程相互等待到某个公共屏障点,然后这一组线程再同时执行。
2)CountDownLatch的计数器的值无法被重置,这个初始值只能被设置一次,是不能够重复使用的;CyclicBarrier是可以重用的。
3)Semaphore:信号量
可以控制某个资源可被同时访问的个数,通过构造函数设定一定数量的许可,通过acquire()获取一个许可,如果没有就等待,而release()释放一个许可。
Semaphore类提供了2个构造器:
//参数permits表示许可数⽬,即同时可以允许多少线程进⾏访问
public Semaphore(int permits) {
sync = new NonfairSync(permits);
}
//这个多了⼀个参数fair表示是否是公平的,即等待时间越久的越先获取许可
public Semaphore(int permits, boolean fair) {
sync = (fair) ? new FairSync(permits) : new NonfairSync(permits);
}
Semaphore类中⽐较重要的⼏个⽅法,⾸先是acquire()、release()⽅法:
//获取⼀个许可
public void acquire() throws InterruptedException { }
//获取permits个许可
public void acquire(int permits) throws InterruptedException { }
//释放⼀个许可
public void release() { }
//释放permits个许可
public void release(int permits) { }
acquire()⽤来获取⼀个许可,若⽆许可能够获得,则会⼀直等待,直到获得许可。
release()⽤来释放许可。注意,在释放许可之前,必须先获获得许可。
图示:
代码实现:
public class SemaphoreTest {
public static void main(String[] args) {
//线程池
ExecutorService exec = Executors.newCachedThreadPool();
//只能5个线程同时访问
final Semaphore semp = new Semaphore(5);
//模拟20个客户端访问
for (int index = 0; index < 20;index++){
final int NO = index;
Runnable run = new Runnable() {
@Override
public void run() {
try {
semp.acquire();
System.out.println("Accessing: " + NO);
Thread.sleep((long) (Math.random() * 1000));
//访问完后,释放,如果屏蔽下面的语句,则在控制台只能打印5条记录,之后线程一直阻塞
semp.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
exec.execute(run);
}
//退出线程池
exec.shutdown();
}
}