1.CountDownLatch
CountDownLatch就像一个计数器,适用于执行给定数量的线程任务。
使用方法:
public CountDownLatch(int count) { };
CountDownLatch只有这一种构造器,需要初始化要完成的任务数量。
可以使用await() 或者 await(long timeout, TimeUnit unit) 方法进行等待,当计数器减少为0时,继续执行之后的代码。每完成一个任务,都可以使用countDown()方法使数量减少1。
举例说明:
public class Test {
public static void main(String[] args) {
final CountDownLatch latch = new CountDownLatch(2);
new Thread(){
public void run() {
try {
System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
Thread.sleep(3000);
System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
latch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
};
}.start();
new Thread(){
public void run() {
try {
System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
Thread.sleep(3000);
System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
latch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
};
}.start();
try {
System.out.println("等待2个子线程执行完毕...");
latch.await();
System.out.println("2个子线程已经执行完毕");
System.out.println("继续执行主线程");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
2.CyclicBarrier
CyclicBarrier和CountDownLatch很相像,区别在于CountDownLatch适用于主线程等待其它分线程跑完后,继续往下执行,而CyclicBarrier适用于各分线程彼此等待,当所有线程结束后再一起往下执行。
使用方法:
public CyclicBarrier(int parties) {
}
public CyclicBarrier(int parties, Runnable barrierAction) {
}
CyclicBarrier有两种构造器,其中一种与CountDownLatch相同,另外一种参数barrierAction定义了当这些线程都达到barrier状态时会执行的内容。
可以使用 await() 方法让该线程等待,等所有线程到达等待状态时,再同时执行之后的代码。还可以使用 await(long timeout, TimeUnit unit) 方法,在超时后让已经到达等待的线程执行之后的代码。
举例说明:
测试类
public class TestFinal {
public static void main(String[] args) {
CyclicBarrier barrier = new CyclicBarrier(3);
barrier.reset();
for (int i = 0; i < 5; i++) {
new MyThread(barrier).start();
}
try {
Thread.sleep(6000);
System.out.println("-----------------------");
System.out.println(barrier.getNumberWaiting() + "个线程正在等待");
System.out.println("-----------------------");
for (int i = 0; i < 2; i++) {
new MyThread(barrier).start();
}
Thread.sleep(6000);
System.out.println("-----------------------");
System.out.println(barrier.getNumberWaiting() + "个线程正在等待");
System.out.println("-----------------------");
for (int i = 0; i < 2; i++) {
new MyThread(barrier).start();
}
Thread.sleep(6000);
System.out.println("-----------------------");
System.out.println(barrier.getNumberWaiting() + "个线程正在等待");
System.out.println("-----------------------");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
线程类
public class MyThread extends Thread{
private CyclicBarrier cyclicBarrier;
public MyThread(CyclicBarrier cyclicBarrier) {
this.cyclicBarrier = cyclicBarrier;
}
@Override
public void run(){
try {
sleep(2000);
System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
cyclicBarrier.await();
sleep(2000);
System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
}
结果
线程Thread-0正在写入数据...
线程Thread-4正在写入数据...
线程Thread-3正在写入数据...
线程Thread-1正在写入数据...
线程Thread-2正在写入数据...
线程Thread-3写入数据完毕
线程Thread-4写入数据完毕
线程Thread-0写入数据完毕
-----------------------
2个线程正在等待
-----------------------
线程Thread-6正在写入数据...
线程Thread-5正在写入数据...
线程Thread-1写入数据完毕
线程Thread-2写入数据完毕
线程Thread-6写入数据完毕
-----------------------
1个线程正在等待
-----------------------
线程Thread-8正在写入数据...
线程Thread-7正在写入数据...
线程Thread-5写入数据完毕
线程Thread-8写入数据完毕
线程Thread-7写入数据完毕
-----------------------
0个线程正在等待
-----------------------
可以看出CyclicBarrier是可以重复使用的,适合反复的批量执行任务。
3.Semaphore
Semaphore可以控制同时访问的线程个数,适用于需要控制同时运行线程数量时使用。
使用方法:
public Semaphore(int permits) { //参数permits表示许可数目,即同时可以允许多少线程进行访问
sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) { //这个多了一个参数fair表示是否是公平的,即等待时间越久的越先获取许可
sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}
通过 acquire() 或 acquire(int permits) 获取一个或 permits个许可,如果没有就等待,而 release() 或 release(int permits) 释放一个或permits个许可。
以上4种方法都会被阻塞,如果想立即得到执行结果,可以使用下面几个方法:
public boolean tryAcquire() { }; //尝试获取一个许可,若获取成功,则立即返回true,若获取失败,则立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { }; //尝试获取一个许可,若在指定的时间内获取成功,则立即返回true,否则则立即返回false
public boolean tryAcquire(int permits) { }; //尝试获取permits个许可,若获取成功,则立即返回true,若获取失败,则立即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { }; //尝试获取permits个许可,若在指定的时间内获取成功,则立即返回true,否则则立即返回false
举例说明:
public class Test {
public static void main(String[] args) {
int N = 8; //工人数
Semaphore semaphore = new Semaphore(5); //机器数目
for(int i=0;i<N;i++)
new Worker(i,semaphore).start();
}
static class Worker extends Thread{
private int num;
private Semaphore semaphore;
public Worker(int num,Semaphore semaphore){
this.num = num;
this.semaphore = semaphore;
}
@Override
public void run() {
try {
semaphore.acquire();
System.out.println("工人"+this.num+"占用一个机器在生产...");
Thread.sleep(2000);
System.out.println("工人"+this.num+"释放出机器");
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}