JUC就是java.util .concurrent工具包的简称。这是一个处理线程的工具包,JDK 1.5开始出现的。
分类说明JUC包常用类有哪些
CountDownLatch是一个同步工具类,用来
协调多个线程之间的同步
,或者说起到线程之间的通信(而不是用作互斥的作用
)。
CountDownLatch能够使一个线程
在等待另外一些线程
完成各自工作之后,再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。当每一个线程完成自己任务后,计数器的值就会减一。当计数器的值为0时,表示所有的线程都已经完成一些任务,然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务。
比如老师检查学生作业,有三个学生,这三个学生需要都做完作业后,老师才一起进行检查。这里,我们把每一个学生对应一个线程,老师对应一个主线程,当主线程要进行检查操作时,必须等待三个线程都处理完了,才开始主线程自己的步骤。
学生类:
/**
* 学生
*/
public class Student implements Runnable{
//线程内共享倒计数门阀
private CountDownLatch downLatch;
private String name;
public Student(CountDownLatch downLatch, String name) {
this.downLatch = downLatch;
this.name = name;
}
public void run() {
System.out.printf("学生%s 开始做作业!\n",name);
try {
TimeUnit.SECONDS.sleep(new Random().nextInt(10));
} catch (Exception e) {
e.printStackTrace();
}
System.out.printf("学生%s 作业结束!\n",name);
//当前线程执行完后,记得调用门阀
downLatch.countDown();
}
}
老师类:
/**
* 老师
*/
public class Teacher {
public static void main(String[] args) {
//创建倒计数(CountDown)门闩(Latch)
CountDownLatch latch = new CountDownLatch(3);
ExecutorService executor = Executors.newCachedThreadPool();
executor.execute(new Student(latch,"A"));
executor.execute(new Student(latch,"B"));
executor.execute(new Student(latch,"C"));
//线程池用完了记得关闭,不然资源一直占用,比如main方法会一直在执行
executor.shutdown();
System.out.printf("老师%s 等待学生作业!\n",Thread.currentThread().getName());
try {
//等待三个线程全部执行完
latch.await();
} catch (Exception e) {
e.printStackTrace();
}
System.out.printf("老师%s 学生作业全部做完,开始检查!\n",Thread.currentThread().getName());
}
}
1.各个线程中最好有异常处理,不要让一个线程阻塞了导致请他线程也跟着阻塞
CyclicBarrier字面意思是“可重复使用的栅栏”,CyclicBarrier 相比 CountDownLatch 来说,要简单很多,其源码没有什么高深的地方,它是 ReentrantLock 和 Condition 的组合使用。
在CyclicBarrier类的内部有一个计数器,每个线程在到达屏障点的时候都会调用await方法将自己阻塞,此时计数器会减1,当计数器减为0的时候所有因调用await方法而被阻塞的线程将被唤醒。这就是实现一组线程相互等待的原理
例如100米赛跑,有3个运动员参加,教练需要看到3个运动员都准备好了,然后才鸣枪,三个运动员同时起跑。现在三个运动员对应三个线程,当教练(主线程)执行100米比赛时,通过查看cyclicBarrier的计数是否为0,为0则所有线程开始都被唤醒开始同时进行。
远动员:
/**
* 运动员
*/
public class Player implements Runnable{
private CyclicBarrier cyclicBarrier;
private String name;
public Player(CyclicBarrier cyclicBarrier, String name) {
this.cyclicBarrier = cyclicBarrier;
this.name = name;
}
public void run() {
try {
//睡眠阻塞
cyclicBarrier.await();
System.out.printf("运动员%s 开始起跑!时间:%s\n",name,getDateTime());
TimeUnit.SECONDS.sleep(new Random().nextInt(10));
} catch (Exception e) {
e.printStackTrace();
}
System.out.printf("运动员%s 100米跑道终点!时间:%s\n",name,getDateTime());
}
public String getDateTime(){
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return sdf.format(d);
}
}
教练:
/**
* 教练
*/
public class Trainer {
public static void main(String[] args) {
int threadCount = 3;
//创建栅栏
CyclicBarrier cyclicBarrier = new CyclicBarrier(threadCount);
ExecutorService executor = Executors.newCachedThreadPool();
for (int i = 1; i <= threadCount; i++) {
executor.execute(new Player(cyclicBarrier,"A"+i));
System.out.printf("运动员%s准备就绪,等待其他玩家!\n","A"+i);
}
executor.shutdown();
}
}
1.CountDownLatch 是一次性的,CyclicBarrier 是可循环利用的
2.CountDownLatch 参与的线程的职责是不一样的,有的在倒计时,有的在等待倒计时结束。CyclicBarrier 参与的线程职责是一样的。
3CountDownLatch是线程组之间的等待,即一个(或多个)线程等待N个线程完成某件事情之后再执行;而CyclicBarrier则是线程组内的等待,即每个线程相互等待,即N个线程都被拦截之后,然后依次执行。
4.CountDownLatch是减计数方式,而CyclicBarrier是加计数方式。
5.CountDownLatch计数为0无法重置,而CyclicBarrier计数达到初始值,则可以重置。
Semaphore用于限制可以访问某些资源(物理或逻辑的)的线程数目,他维护了一个许可证集合,有多少资源需要限制就维护多少许可证集合,假如这里有N个资源,那就对应于N个许可证,同一时刻也只能有N个线程访问。一个线程获取许可证就调用acquire方法,用完了释放资源就调用release方法。
Semaphore 类是一个计数信号量,必须由获取它的线程释放, 通常用于限制可以访问某些资源(物理或逻辑的)线程数目
比如一个停车场有三个车位,有6辆车进入,那么当停满3辆车后,停车场是不能再进去停车场的,必须其中一个车出来,空出一个车位后,后面的车才能再次进入。车位就相当于Semaphore信号量,车辆可看做一个线程,程序中只允许3个线程进行执行,不管后面线程有多少,当一个线程执行完了,那么后面线程才能有一个开始执行。
车辆类:
public class Car implements Runnable{
private Semaphore semaphore;
private String name;
public Car(Semaphore semaphore, String name) {
this.semaphore = semaphore;
this.name = name;
}
public void run() {
try {
//查看是否还有车位
semaphore.acquire();
System.out.printf("车主%s 有车位,开车进入!\n",name);
TimeUnit.SECONDS.sleep(new Random().nextInt(10));
System.out.printf("车主%s 离开停车场!\n",name);
//释放占用的车位
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
停车场类:
/**
* 停车场
*/
public class Park {
public static void main(String[] args) {
//信号量,即3个车位
Semaphore ParkingLot = new Semaphore(3);
ExecutorService executor = Executors.newCachedThreadPool();
//6辆车开车进入
for (int i = 1; i <= 6; i++) {
executor.execute(new Car(ParkingLot,"A"+i));
}
executor.shutdown();
}
}
Exchanger并发辅助类,允许在并发任务之间交换数据。具体来说Exchanger类在两个线程之间定义同步点。当两个线程到达同步点时,它们交换数据结构。
Exchanger 是 JDK 1.5 开始提供的一个用于两个工作线程之间交换数据的封装工具类,简单说就是一个线程在完成一定的事务后想与另一个线程交换数据,则第一个先拿出数据的线程会一直等待第二个线程,直到第二个线程拿着数据到来时才能彼此交换对应数据。
平时没怎么用到
两个生产者线程,当调用Exchanger时,会互相传递数据
public class ProducerA extends Thread{
private Exchanger<Integer> exchanger;
private static int data = 2;
public ProducerA(Exchanger<Integer> exchanger, String name) {
super.setName(name);
this.exchanger = exchanger;
}
@Override
public void run() {
System.out.println(getName()+" 交换前:" + data);
try {
TimeUnit.SECONDS.sleep(2);
data = exchanger.exchange(data);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName()+" 交换后:" + data);
}
}
public class ProducerB extends Thread{
private Exchanger<Integer> exchanger;
private static int data = 0;
public ProducerB(Exchanger<Integer> exchanger, String name) {
this.exchanger = exchanger;
super.setName(name);
}
@Override
public void run() {
System.out.println(getName()+" 交换前:" + data);
try {
TimeUnit.SECONDS.sleep(1);
data = exchanger.exchange(data);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName()+" 交换后:" + data);
}
}
public class Test {
public static void main(String[] args) throws InterruptedException {
Exchanger<Integer> exchanger = new Exchanger<Integer>();
new ProducerA(exchanger,"AA").start();
new ProducerB(exchanger,"BB").start();
TimeUnit.SECONDS.sleep(5);
}
}
Java Exchanger 必知必会
Semaphore的工作原理及实例
semaphore/
Semaphore 相关整理
Java并发编程之CyclicBarrier详解
CountDownLatch的理解和使用