多线程（8）-同步辅助类CountDownLatch&CyclicBarrier& Semaphor

最新推荐文章于 2024-11-03 11:01:20 发布

weixin_33777877

最新推荐文章于 2024-11-03 11:01:20 发布

阅读量60

点赞数

文章标签： java python 操作系统

原文链接：https://my.oschina.net/haoran100/blog/719478

版权

2019独角兽企业重金招聘Python工程师标准>>>

一、CountDownLatch

CountDownLatch是一个计数同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待

主要的方法

public CountDownLatch(int count);构造计数的个数
public void await() throws InterruptedException;当前线程使用CountDownLatch等待，阻塞当前线程
public void countDown();计数器减1

代码示例

package wang.conge.javasedemo.core.thread;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {

	public static void main(String[] args) {
		CountDownLatch countDownLatch = new CountDownLatch(3);
		
		for (int i = 0; i < 3; i++) {
			new Thread(()->{
				System.out.println("child thread run");
				countDownLatch.countDown();
			}).start();
		}
		
		System.out.println("main thread run");
		
		try {
			countDownLatch.await();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println("main thread finished");
	}

}

代码解析

创建CountDownLatch 实例，并赋予countDown个数
主线程运行，使用CountDownLatch await，阻塞当前线程
每个子线程运行，countDown个数减1
当countDown个数减为0时，主线程不在因为CountDownLatch阻塞，继续运行

二、CyclicBarrier

CyclicBarrier是一个同步辅助类，允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。因为该 barrier 在释放等待线程后可以重用，所以称它为循环的 barrier。

CountDownLatch和CyclicBarrier对比

CountDownLatch的作用是允许1或N个线程等待其他线程完成执行；而CyclicBarrier则是允许N个线程相互等待。
CountDownLatch的计数器无法被重置；CyclicBarrier的计数器可以被重置后使用，因此它被称为是循环的barrier。

主要的方法

public CyclicBarrier(int parties);定义parties个线程参与数量
public CyclicBarrier(int parties, Runnable barrierAction) ;定义parties个线程参与数量，当这些线程都参数时，执行barrierAction事情

代码示例

package wang.conge.javasedemo.core.thread;

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierTest {

	public static void main(String[] args) {
		CyclicBarrier cyclicBarrier = new CyclicBarrier(5);

		for (int i = 0; i < 5; i++) {
			new Thread(()->{
				System.out.println("child thread start");
				
				try {
					cyclicBarrier.await();
				} catch (Exception e) {
					e.printStackTrace();
				}
				
				System.out.println("child thread end");
			}).start();
		}
		
	}

}

代码解析

多个线程共同商量好，都等着，等的数量够了，然后大家在一起继续执行
CyclicBarrier 还可以重置，也就是还可以再次一起等几回

三、Semaphore

信号量机制

信号量在操作系统中一般用来管理数量有限的资源.
每类资源有一个对应的信号量,信号量的值表示资源的可用数量.
在使用资源时,要先从该信号量上获取一个使用许可.成功获取许可之后,资源可用数量减1.
在持有许可期,使用者可以对获取资源进行操作.
完成对资源的使用之后,需要在信号量上释放一个许可,资源可用数加1,允许其他使用者获取资源.
当资源可用数为0的时候,需要获取资源的线程以阻塞的方式来等待资源变为可用,或者过段时间之后再检查资源是否变为可用.

java实现

在java中有相应的Semaphore实现类
在创建Semaphore类的对象时指定资源的可用数
通过acquire方法以阻塞式的方式获取许可
而tryAcquire方法以非阻塞式的方式来获取许可
当需要释放许可时,使用release方法
Semaphore类也支持同时获取和释放多个资源的许可
通过acquire方法获取许可的过程是可以被中断的.如果不希望被中断,那么可以使用acquireUninterruptibly方法
Semaphore也支持在分配许可时使用公平模式,通过把构造方法的第二个参数设置为true来使用该模式.在公平模式下,当资源可用时,等待线程按照调用acquire方法申请资源的顺序依次获取许可.在进行资源管理时,一般使用公平模式,以避免造成线程饥渴问题
需要注意的是获取资源时,通过synchronized关键词或锁声明同步.这是因为Semaphore类只是一个资源数量的抽象表示,并不负责管理资源对象本身,可能有多个线程同时获取到资源使用许可,因此需要使用同步机制避免数据竞争.

代码示例

class Pool {
   private static final int MAX_AVAILABLE = 100;
   private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);

   public Object getItem() throws InterruptedException {
     available.acquire();
     return getNextAvailableItem();
   }

   public void putItem(Object x) {
     if (markAsUnused(x))
       available.release();
   }

   // Not a particularly efficient data structure; just for demo

   protected Object[] items = ... whatever kinds of items being managed
   protected boolean[] used = new boolean[MAX_AVAILABLE];

   protected synchronized Object getNextAvailableItem() {
     for (int i = 0; i < MAX_AVAILABLE; ++i) {
       if (!used[i]) {
          used[i] = true;
          return items[i];
       }
     }
     return null; // not reached
   }

   protected synchronized boolean markAsUnused(Object item) {
     for (int i = 0; i < MAX_AVAILABLE; ++i) {
       if (item == items[i]) {
          if (used[i]) {
            used[i] = false;
            return true;
          } else
            return false;
       }
     }
     return false;
   }
 }}