CountDownLatch 闭锁
闭锁是一种同步工具类,可以延迟线程的进度知道其到达终止状态。闭锁的作用相当于一扇门(await):在闭锁到达结束状态之前,这扇门一直是关闭的,不允许任何线程通过,当到达结束状态时(所有线程均到达countDown),这扇门会打开并且允许所有的线程通过。而且,当门打开了,就永远保持打开状态。
作用:
1、确保某些活动直到其他活动都完成后才继续执行。
2、确保某个服务在其依赖的所有其他服务都已经启动之后才启动。
3、等待直到某个操作的所有参与者都就绪再继续执行。
public class CountDownLatchTest {
public static void main(String[] args) {
CountDownLatch latch = new CountDownLatch(3);
new Thread(new Father(latch)).start();
new Thread(new Mother(latch)).start();
new Thread(new GrandmaAndLizzy(latch)).start();
try {
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Start lauch!!");
}
public static class Father implements Runnable {
CountDownLatch latch;
public Father(CountDownLatch latch) {
this.latch = latch;
}
@Override
public void run() {
System.out.println("Father ready!");
latch.countDown();
}
}
public static class Mother implements Runnable {
CountDownLatch latch;
public Mother(CountDownLatch latch) {
this.latch = latch;
}
@Override
public void run() {
System.out.println("Mother ready!");
latch.countDown();
}
}
public static class GrandmaAndLizzy implements Runnable {
CountDownLatch latch;
public GrandmaAndLizzy(CountDownLatch latch) {
this.latch = latch;
}
@Override
public void run() {
System.out.println("GrandmaAndLizzy ready!");
latch.countDown();
}
}
}
FutureTask
FutureTask 实现了Future接口,表示一种抽象的可生成结果(可撤销、超时get)的计算。
FuturTask 表示的计算是通过Callable 来实现的,相当于一种可生成结果的Runnable,可以处于以下三种状态:等外运行、正在运行和运行完成。“运行完成”表示计算的所有可能结束方式,包括正常结束、由于取消而结束和由于异常而结束等。当FutureTask进入完成状态后,它会永远停止在这个状态上。
FutureTask.get()的行为取决于任务的状态,如果任务已经完成,那么get会立即返回结果,否则get将阻塞知道任务进入完成状态,然后返回结果或者抛出异常。FutureTask将计算结果从执行计算的线程传递到获取这个结果的线程,而且FutureTask的规范确保了这种传递过程能实现结果的安全发布。
FuturTask在Executor框架中表示异步任务。
public class MyFutureTaskDemo {
public static void main(String[] args) {
final FutureTask<String> task = new FutureTask<String>(
new Callable<String>() {
@Override
public String call() throws Exception {
System.out.println("let's go!");
Thread.sleep(3000);
return "Hello Beautiful World!";
}
});
try {
System.out.println("start get!");
new Thread(task).start();
String result = task.get();
System.out.println("finish get=" + result);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
Semaphore 信号量
可以用来控制同时访问某个特定资源的操作数量,或者同时执行某个指定操作的数量。计数信号量还可以用来实现某种资源池,或者对容器施加边界。
acquire 从此信号量获取一个许可,在提供一个许可前一直将线程阻塞,否则线程被中断。获取一个许可(如果提供了一个)并立即返回,将可用的许可数减 1。
release 释放一个许可,将其返回给信号量。释放一个许可,将可用的许可数增加 1。如果任意线程试图获取许可,则选中一个线程并将刚刚释放的许可给予它。然后针对线程安排目的启用(或再启用)该线程。
public class MySemaphoreDemo {
private final Semaphore sem;
public MySemaphoreDemo(int count) {
sem = new Semaphore(count);
}
// 申请资源
public void getResource() throws InterruptedException {
sem.acquire();
System.out.println("资源已下发");
}
// 释放资源
public void releaseResource() {
sem.release();
System.out.println("资源已回收");
}
public static void main(String[] args) {
final MySemaphoreDemo pool = new MySemaphoreDemo(3);
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
pool.getResource();
Thread.sleep(5000);
pool.releaseResource();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
}
CyclicBarrier 栅栏
CyclicBarrier 是一个同步辅助类,它允许一组线程互相等待,直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中,这些线程必须不时地互相等待,此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用,所以称它为循环 的 barrier。
CyclicBarrier 支持一个可选的 Runnable 命令,在一组线程中的最后一个线程到达之后(但在释放所有线程之前),该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新共享状态,此屏障操作 很有用。
CyclicBarrier 类似于闭锁,它能阻塞一组线程直到某个事件发生。栅栏与闭锁的关键区别在于,所有线程必须同时到达栅栏位置,才能继续执行。闭锁用于等待事件,而栅栏用于等待其他先。
public class MyBarrierDemo {
public static void main(String[] args) {
CyclicBarrier barrier = new CyclicBarrier(3, new Runnable() {
@Override
public void run() {
System.out.println("当前线程" + Thread.currentThread().getName());
}
});
new Thread(new Father(barrier)).start();
new Thread(new Mother(barrier)).start();
new Thread(new GrandmaAndLizzy(barrier)).start();
}
public static class Father implements Runnable {
CyclicBarrier barrier;
public Father(CyclicBarrier barrier) {
this.barrier = barrier;
}
@Override
public void run() {
System.out.println("Father ready!");
try {
barrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println("Every arrive ,Start lauch!!");
}
}
public static class Mother implements Runnable {
CyclicBarrier barrier;
public Mother(CyclicBarrier barrier) {
this.barrier = barrier;
}
@Override
public void run() {
System.out.println("Mother ready!");
try {
barrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println("Every arrive ,Start lauch!!");
}
}
public static class GrandmaAndLizzy implements Runnable {
CyclicBarrier barrier;
public GrandmaAndLizzy(CyclicBarrier barrier) {
this.barrier = barrier;
}
@Override
public void run() {
try {
System.out.println("GrandmaAndLizzy ready!");
Thread.sleep(3000);
barrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println("Every arrive ,Start lauch!!");
}
}
}
Exchanger 双边栅栏
Exchanger 是一种两方栅栏:各方栅栏在阻塞位置上交换数据(双方都达到阻塞位置时)。当两方执行不对称的操作时,会非常有用。当两个线程通过Exchanger交换对象时,这种交换就把这两个对象安全的发布给另一方。
public class ExchangeTest {
public static void main(String[] args) {
Exchanger<List<Integer>> exchanger = new Exchanger<List<Integer>>();
new Consumer(exchanger).start();
new Producer(exchanger).start();
}
static class Producer extends Thread {
List<Integer> list = new ArrayList<Integer>();
Exchanger<List<Integer>> exchanger = null;
public Producer(Exchanger<List<Integer>> exchanger) {
this.exchanger = exchanger;
}
@Override
public void run() {
Random random = new Random();
for (int i = 0; i < 10; i++) {
list.clear();
list.add(random.nextInt(100));
list.add(random.nextInt(100));
list.add(random.nextInt(100));
list.add(random.nextInt(100));
list.add(random.nextInt(100));
if (list.size() == 5) {
System.out.println("Producer :before exchange:"
+ list.get(0) + "," + list.get(1) + ","
+ list.get(2) + "," + list.get(3) + ","
+ list.get(4));
} else {
System.out.println("Producer :before exchange: is null");
}
try {
list = exchanger.exchange(list);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (list.size() == 5) {
System.out.println("Producer :after exchange:"
+ list.get(0) + "," + list.get(1) + ","
+ list.get(2) + "," + list.get(3) + ","
+ list.get(4));
} else {
System.out.println("Producer :after exchange: is null");
}
System.out
.println("==================Producer======================");
}
}
}
static class Consumer extends Thread {
List<Integer> list = new ArrayList<Integer>();
Exchanger<List<Integer>> exchanger = null;
public Consumer(Exchanger<List<Integer>> exchanger) {
this.exchanger = exchanger;
}
public void run() {
for (int i = 0; i < 10; i++) {
if (list.size() == 5) {
System.out.println("Consumer :before exchange:"
+ list.get(0) + "," + list.get(1) + ","
+ list.get(2) + "," + list.get(3) + ","
+ list.get(4));
} else {
System.out.println("Consumer :before exchange: is null");
}
try {
list = exchanger.exchange(list);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (list.size() == 5) {
System.out.println("Consumer :after exchange:"
+ list.get(0) + "," + list.get(1) + ","
+ list.get(2) + "," + list.get(3) + ","
+ list.get(4));
} else {
System.out.println("Consumer :after exchange: is null");
}
System.out
.println("==================Consumer======================");
}
}
}
}