CountDownLatch、CyclicBarrier和Semaphore代码使用

一句话总结三者的区别:Semaphore用来限制资源的使用，比如连接池的Connection. CountDownLatch用于一个线程等待一些子任务完成的时候自己再执行，比如初始化，多个线程一起初始化，等子初始化都完成了，主线程进行处理，这里有主从线程的概念。而CyclicBarrier则没有主从线程的概念，它使得一组线程达到一个统一的状态，比如8个奥运会选手代表8个线程，让他们都走到起跑线的时候，这个可以通过CyclicBarrier让他们都跑到起跑线，然后让他们开始比赛吧。CyclicBarrier可以重用，而CountDownLatch不可以重用。你懂的！下面直接贴代码，

 

Semaphore代码：

public class MySemaphore {
	//假如我们只有5个资源，而一共有8个人要使用资源，所以对资源的使用进行限制操作
	Semaphore semaphore = new Semaphore(5);
	
	
	
	class Worker extends Thread{
		@Override
		public void run() {
			try {
				semaphore.acquire();
				System.out.println("线程"+Thread.currentThread().getName()+"已经获得到了资源");
				Thread.sleep(1000);//模仿处理资源
				System.out.println("线程"+Thread.currentThread().getName()+"利用资源处理完自己的工作");
				semaphore.release();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
		}
	}
	
	public static void main(String[] args) {
		
		MySemaphore my = new MySemaphore();
		for(int i=0;i<8;i++){
			my.new Worker().start();
		}
	}
}
	

测试结果:

线程Thread-0已经获得到了资源
线程Thread-1已经获得到了资源
线程Thread-2已经获得到了资源
线程Thread-3已经获得到了资源
线程Thread-5已经获得到了资源
线程Thread-1利用资源处理完自己的工作
线程Thread-5利用资源处理完自己的工作
线程Thread-3利用资源处理完自己的工作
线程Thread-4已经获得到了资源
线程Thread-0利用资源处理完自己的工作
线程Thread-6已经获得到了资源
线程Thread-2利用资源处理完自己的工作
线程Thread-7已经获得到了资源
线程Thread-7利用资源处理完自己的工作
线程Thread-4利用资源处理完自己的工作
线程Thread-6利用资源处理完自己的工作

CyclicBarrier代码：

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class MyCyclicBarrier {
	private CyclicBarrier  barrier = new CyclicBarrier(5,new Runnable() {
		
		@Override
		public void run() {
			System.out.println("所有数据读取完毕,我们可以对数据进行操作");
		}
	});
	
	
	
	class People extends Thread{
		@Override
		public void run() {
			try {
				System.out.println("线程"+Thread.currentThread().getName()+"正在执行读取数据的操作");
				Thread.sleep(1000);
				System.out.println("线程"+Thread.currentThread().getName()+"正在等他其他线程的子任务结束");
				barrier.await();
			} catch (InterruptedException | BrokenBarrierException e) {
				e.printStackTrace();
			}
		}
	}
	
	
	public static void main(String[] args) {
		MyCyclicBarrier my = new MyCyclicBarrier();
		for(int i=0;i<5;i++){
			my.new People().start();
		}
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("CyclicBarrier重用");

		for(int i=0;i<5;i++){
			my.new People().start();
		}
	}
}

 

测试结果：

线程Thread-2正在执行读取数据的操作
线程Thread-1正在执行读取数据的操作
线程Thread-3正在执行读取数据的操作
线程Thread-0正在执行读取数据的操作
线程Thread-4正在执行读取数据的操作
线程Thread-1正在等他其他线程的子任务结束
线程Thread-4正在等他其他线程的子任务结束
线程Thread-3正在等他其他线程的子任务结束
线程Thread-0正在等他其他线程的子任务结束
线程Thread-2正在等他其他线程的子任务结束
所有数据读取完毕,我们可以对数据进行操作
CyclicBarrier重用
线程Thread-5正在执行读取数据的操作
线程Thread-6正在执行读取数据的操作
线程Thread-7正在执行读取数据的操作
线程Thread-8正在执行读取数据的操作
线程Thread-9正在执行读取数据的操作
线程Thread-5正在等他其他线程的子任务结束
线程Thread-8正在等他其他线程的子任务结束
线程Thread-7正在等他其他线程的子任务结束
线程Thread-6正在等他其他线程的子任务结束
线程Thread-9正在等他其他线程的子任务结束
所有数据读取完毕,我们可以对数据进行操作

CountDownLatch代码：

import java.util.concurrent.CountDownLatch;

public class MyCountDownLatch {
	private CountDownLatch latch = new CountDownLatch(2);
	
	public Thread t1 = new Thread(new Runnable() {
		
		@Override
		public void run() {
			System.out.println("线程t1正在执行子任务");
			latch.countDown();		}
	});
	
	public Thread t2 = new Thread(new Runnable() {
		
		@Override
		public void run() {
			System.out.println("线程t2正在执行子任务");
			latch.countDown();		}
	});
	
	
	public static void main(String[] args) {
		System.out.println("主线程执行任务需要子任务工作");
		MyCountDownLatch my = new MyCountDownLatch(); 
		CountDownLatch latch = my.latch;
		try {
			my.t1.start();
			my.t2.start();
			latch.await();
			System.out.println("主线程正在执行主任务,子任务已经完成");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}
}

测试结果:

主线程执行任务需要子任务工作
线程t1正在执行子任务
线程t2正在执行子任务
主线程正在执行主任务,子任务已经完成