一、CountDownLatch
一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待。
用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法,所以在当前计数到达零之前,await 方法会一直受阻塞。之后,会释放所有等待的线程,await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数,请考虑使用 CyclicBarrier。
二、
三、Exchanger
四、Semaphore
1.
运行结果:
0进入景区
4进入景区
2进入景区
0游览0s
...
未按照顺序进行执行
一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待。
用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法,所以在当前计数到达零之前,await 方法会一直受阻塞。之后,会释放所有等待的线程,await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数,请考虑使用 CyclicBarrier。
import java.util.concurrent.CountDownLatch;
/**
* 某一个事情按照指定的步骤进行
*/
public class CountDownLatchDemo {
/**
* @description
* 去上班之前
* 1.洗脸
* 2.刷牙
* 3.吃饭
* @param args
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException {
// 指明时间的数量
CountDownLatch latch = new CountDownLatch(3);
new Thread(new WashFace(latch)).start();
new Thread(new WashTooth(latch)).start();
new Thread(new Eat(latch)).start();
// 阻塞线程,直到 latch 的值为 0
latch.await();
// 若不适用 CountDownLatch 则会出现,主线程信息先打印,而等待其他线程信息的情况
System.out.println("去上班");
}
}
class WashFace implements Runnable{
private CountDownLatch latch = null ;
public WashFace(){
}
public WashFace(CountDownLatch latch){
this.latch = latch ;
}
@Override
public void run() {
System.out.println("洗脸");
latch.countDown();
}
}
class WashTooth implements Runnable{
private CountDownLatch latch = null ;
public WashTooth(){
}
public WashTooth(CountDownLatch latch){
this.latch = latch ;
}
@Override
public void run() {
System.out.println("刷牙");
latch.countDown();
}
}
class Eat implements Runnable{
private CountDownLatch latch ;
public Eat(){
}
public Eat(CountDownLatch latch){
this.latch = latch ;
}
@Override
public void run() {
System.out.println("吃饭");
latch.countDown();
}
}
二、
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**
* 需求:某一个时间点要求各个线程统一开始执行
* 先执行到该时间点的线程等待其他线程;然后所有线程一起运行
*/
public class CyclicBarrierDownLatchDemo {
/**
* @description
* 赛马
* 1.比赛开始前,所有马匹被从其他地方牵引到起点位置
* 2.先到的等待后到的
* 3.比赛开始,所有马匹开始赛跑
* @param args
*/
public static void main(String[] args) {
CyclicBarrier cb = new CyclicBarrier(3);
new Thread(new BlackHorse(cb)).start();
new Thread(new WhiteHorse(cb)).start();
new Thread(new GreyHorse(cb)).start();
System.out.println("=============");
}
}
class BlackHorse implements Runnable{
private CyclicBarrier cb = null ;
public BlackHorse(){
}
public BlackHorse(CyclicBarrier cb){
this.cb = cb ;
}
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("黑马花费1S到达起点");
try {
cb.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println("黑马开始奔跑");
}
}
class WhiteHorse implements Runnable{
private CyclicBarrier cb = null ;
public WhiteHorse(){
}
public WhiteHorse(CyclicBarrier cb){
this.cb = cb ;
}
@Override
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("白马花费2S到达起点");
try {
cb.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println("白马开始奔跑");
}
}
class GreyHorse implements Runnable{
private CyclicBarrier cb = null ;
public GreyHorse(){
}
public GreyHorse(CyclicBarrier cb){
this.cb = cb ;
}
@Override
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("灰马花费3S到达起点");
try {
cb.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println("灰马开始奔跑");
}
}
三、Exchanger
import java.util.concurrent.Exchanger;
/**
* 线程间交换信息,允许线程间相互等待
*/
public class ExchangerDemo {
/**
* @description
* 1.A来到指定地点等待B,发出信息
* 2.B来到指定地点等待A,发出信息
* @param args
*/
public static void main(String[] args) {
Exchanger<String> ex = new Exchanger<String>();
new Thread(new PersonA(ex)).start();
new Thread(new PersonB(ex)).start();
System.out.println("============");
}
}
class PersonB implements Runnable{
private Exchanger<String> ex ;
public PersonB(Exchanger<String> ex){
this.ex = ex ;
}
@Override
public void run() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("B用5S到达了指点地点");
try {
String result = ex.exchange("宝塔镇河妖");
if(result.equals("天王盖地虎")){
System.out.println("自己人");
}else{
System.out.println("兄弟们,抄家伙儿");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class PersonA implements Runnable{
private Exchanger<String> ex ;
public PersonA(Exchanger<String> ex){
this.ex = ex ;
}
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("A用1S到达了指点地点");
try {
String result = ex.exchange("天王盖地虎");
if(result.equals("宝塔镇河妖")){
System.out.println("自己人");
}else{
System.out.println("兄弟们,抄家伙儿");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
四、Semaphore
1.
import java.util.concurrent.Semaphore;
/**
* 保护一段代码,不能同时被超过N个线程访问
*/
public class SemaphoreDemo {
/**
* @description
* 景区某一个景点,每次仅允许3人进入访问;一旦有人出来,再次放人进入
* @param args
*/
public static void main(String[] args) {
Semaphore se = new Semaphore(3);
// 保证公平,按照顺序执行
// Semaphore se = new Semaphore(3,true);
for(int i = 0 ; i < 100 ; i++){
new Thread(new Visitor(se, i)).start();
}
}
}
class Visitor implements Runnable{
private Semaphore se = null ;
private int i ;
public Visitor(){
}
public Visitor(Semaphore se,int i){
this.se = se ;
this.i = i ;
}
@Override
public void run() {
try {
se.acquire();
System.out.println(i+"进入景区");
Thread.sleep(i*1000);
System.out.println(i+"游览"+i*1000+"s");
se.release();
System.out.println(i+"离开景区");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行结果:
0进入景区
4进入景区
2进入景区
0游览0s
...
未按照顺序进行执行