Semaphore
Semaphore被翻译成信号量，他是并发编程领域得一大利器。信号量模型比较简单，可以概况为：一个计数器，一个等待队列，三个方法。其中这三个方法分别是：init()、down()和up()。我们就是通过这三个方法来操作计数器和等待队列，从而实现对线程的并发控制。
- init():设置计数器的初始值。
- down():计数器的值减 1;如果此时计数器的值小于 0，则当前线程将被阻塞，否则当 前线程可以继续执行。
- up():计数器的值加 1;如果此时计数器的值小于或者等于 0，则唤醒等待队列中的一个 线程，并将其从等待队列中移除。
几乎每个高级编程语言都有对信号量模型的实现。在Java SDK里面，信号量模型是由 java.util.concurrent.Semaphore 实现的，Semaphore 这个类能够保证这三个方法都是原子操作，down() 和 up() 对应的则是 acquire() 和 release()。
acquire()和release()方法其实可以理解为jdk里的java.util.concurrent.locks.ReentrantLock类方法的lock()和unlock()，持有锁和释放锁的过程。不同的是lock只能实现对一个线程的控制，而Semaphore可以允许多个线程访问一个临界区。
下面是使用Semaphore控制线程的例子：
public class SemaphoreTest {
private static int count;
//初始化信号量为 1
private static final Semaphore semaphore = new Semaphore(1); //相当于信号量模型的init()方法
public static void addOne() throws InterruptedException {
//使用信号量保证互斥，只有一个线程进入
semaphore.acquire(); //相对于信号量模型的down()方法
try {
count++;
} finally {
semaphore.release();
}
}
public static int getCount() {
return count;
}
public static void main(String[] args) throws InterruptedException {
//模拟100个线程同时访问
CountDownLatch countDownLatch = new CountDownLatch(1);
for (int i = 0; i < 100; i++) {
new Thread(() -> {
try {
addOne();
countDownLatch.await();
System.out.println(count);
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
countDownLatch.countDown();
TimeUnit.SECONDS.sleep(5);
int count = getCount();
System.out.println(count);
}
}
这里的addOne()方法每次只允许1个线程访问，当然你如果想要N个线程同时访问只需要在构造的时候new Semaphore(N)填入N的值即可。
里面逻辑很简单，每个线程进来就会执行semaphore.acquire()方法将计数器减1，当计数器的值小于0的时候就会阻塞，大于等于0的时候就会往下执行。当执行到semaphore.release()的时候就会将计数器加1，当计数器大于等于0的时候其他线程就会被唤醒继续执行。
CountDownLatch
CountDownLatch和Semaphore一样都是在java1.5版本引入的，都是为了解决多线程并发问题，不同的是Semaphore是为了解决多个线程同时访问资源，而CountDownLatch为了协调多个线程的执行。
打个比方，有A和B两个线程，主线程需要等A和B两个线程都执行完之后才可以做后续的业务，这个时候就可以就可以使用CountDownLatch。
CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，主线程就可以继续工作了。
public class CountDownLatchTest {
public static void main(String[] args) throws Exception{
/*创建CountDownLatch实例,计数器的值初始化为3*/
final CountDownLatch downLatch = new CountDownLatch(3);
/*创建三个线程,每个线程等待1s,表示执行比较耗时的任务*/
for(int i = 0;i < 3;i++){
final int num = i;
new Thread(new Runnable() {
public void run() {
try {
Thread.sleep(1000);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(String.format("thread %d has finished",num));
/*任务完成后调用CountDownLatch的countDown()方法*/
downLatch.countDown();
}
}).start();
}
/*主线程调用await()方法,等到其他三个线程执行完后才继续执行*/
downLatch.await();
System.out.print("all threads have finished,main thread will continue run");
}
}
以上代码设置了CountDownLatch计数器初始化值为3，主线程会阻塞在downLatch.await()这一行，直到3个线程都执行完downLatch.countDown()方法后主线程才会继续执行。
CyclicBarrier
CyclicBarrier和CountDownLatch类似都可以实现线程同步，不同的是CountDownLatch是一次性的，计数器到0就没办法重置了。CyclicBarrier设置的初始值会在所有线程调用完await()方法后自动重置成之前的值，并且CyclicBarrier还有一个回调线程，每次初始值置为0后就会调用回调线程执行。
public static void main(String[] args) {
int i = 3;
CyclicBarrier cyclicBarrier = new CyclicBarrier(3, new Runnable() {
@Override
public void run() {
System.out.println("所有线程等待完成");
}
});
while (i > 0) {
i--;
new Thread(new Runnable() {
@Override
public void run() {
try {
TimeUnit.SECONDS.sleep((new Random().nextInt(5)));
System.out.println(Thread.currentThread().getName() + "线程准备就绪.." +"有"+ cyclicBarrier.getNumberWaiting() + "个线程已经开始等待");
cyclicBarrier.await();
System.out.println(Thread.currentThread().getName() + "线程执行完成..");
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
}
int j = 3;
while (j > 0) {
j--;
new Thread(new Runnable() {
@Override
public void run() {
try {
TimeUnit.SECONDS.sleep((new Random().nextInt(5)));
System.out.println(Thread.currentThread().getName() + "线程准备就绪.." +"有"+ cyclicBarrier.getNumberWaiting() + "个线程已经开始等待");
cyclicBarrier.await();
System.out.println(Thread.currentThread().getName() + "线程执行完成..");
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
}
}
执行结果
Thread-0线程准备就绪..有0个线程已经开始等待
Thread-2线程准备就绪..有1个线程已经开始等待
Thread-5线程准备就绪..有1个线程已经开始等待
所有线程等待完成
Thread-5线程执行完成..
Thread-0线程执行完成..
Thread-2线程执行完成..
Thread-1线程准备就绪..有0个线程已经开始等待
Thread-4线程准备就绪..有1个线程已经开始等待
Thread-3线程准备就绪..有2个线程已经开始等待
所有线程等待完成
Thread-3线程执行完成..
Thread-1线程执行完成..
Thread-4线程执行完成..
总结
Semaphore,CountDownLatch,CyclicBarrier底层都是通过AQS(AbstractQueuedSynchronizer)来实现并发操作的。
Semaphore信号量模型是解决并发编程领域的互斥问题，即同时只能有规定个数的线程访问共享资源。CountDownLatch和CyclicBarrier是解决同步问题，即线程之间如何通信、协作。
说细点CountDownLatch 主要用来解决一个线程等待多个线程的场景，可以类比旅游团团长要等待所有的游客到齐才能去下一个景点；而CyclicBarrier 是一组线程之间互相等待，更像是几个驴友之间不离不弃。除此之外CountDownLatch 的计数器是不能循环利用的，也就是说一旦计数器减到 0，再有线程调用await()，该线程会直接通过。但CyclicBarrier 的计数器是可以循环利用的，而且具备自动重置的功能，一旦计数器减到 0 会自动重置到你设置的初始值。除此之外，CyclicBarrier 还可以设置回调函数，可以说是功能丰富。
网友评论