Java并发-CountDownLatch、CyclicBarrier和Semaphore

客官°小女子只卖身不卖艺 2022-04-04 15:24 332阅读 0赞

# 1.Semaphore #

Semaphore，中文名信号量，Semaphore可以控制访问该资源的线程数量。  
通过构造方法来申明所拥有的资源额个数。

public Semaphore(int permits) { 
            sync = new NonfairSync(permits);
        }
        public Semaphore(int permits, boolean fair) { 
            sync = fair ? new FairSync(permits) : new NonfairSync(permits);
        }

通过acquire（）获得许可，如果没有就等待，release（）释放许可，tryAcquire（）来判断是否还有空闲的资源，也可设置等待的时间。

public void acquire() throws InterruptedException { }
      public void acquire(int permits) throws InterruptedException { }
      public void release(int permits) { }
      public void release() { }
      public boolean tryAcquire() { }
      public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException {  };  
      public boolean tryAcquire(int permits) {  }
      public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException {  };

简单DEMO，共有5台机器可以操作，每个线程表示一个工人。

public class test1 implements Runnable{ 
    	private Machine ma = new Machine();
    
    	public static void main(String[] args) throws InterruptedException { 
    		Runnable r = new test1();
    		for(int i=0;i<8;i++) { 
    			Thread t =  new Thread(r);
    			t.start();
    		}
    	}
    	@Override
    	public  void run() { 
    		System.out.println(Thread.currentThread()+"获得生产任务");
    		ma.work(Thread.currentThread());
    	}	
    }
    class Machine{ 
    	//机器的数量
    	private int count = 5 ;
    	Semaphore se = new Semaphore(count);
    	public void work(Thread t) { 
    		try { 
    			se.acquire();
    			System.out.println(t.getName()+"在进行运行");
    			t.sleep(2000);
    			System.out.println(t.getName()+"运行完毕");
    			se.release();
    		} catch (InterruptedException e) { 
    			e.printStackTrace();
    		}
    	}
    }

# 2.CountDownLatch #

CountDownLatch，中文倒数闸门，当一个线程需要等待其他线程完成后再继续下一步，有一点join()方法的意思。

*  通过构造方法来申明需要等待的线程数量。

public CountDownLatch(int count) { }

*  关键方法

//让线程进入等待，知道count的数值为0时继续进行
    public void await() throws InterruptedException { }
    //和await一样，只是多了一个最长的等待时间
    public boolean await(long timeout, TimeUnit unit){ }
    //count的数值减1
    public void countDown() { }

*  简单DEMO

public class test1 implements Runnable{ 
    	private static CountDownLatch cdl = new CountDownLatch(3);
    	public static void main(String[] args) throws InterruptedException { 
    		Runnable r = new test1();
    		for(int i=0;i<3;i++) { 
    			Thread t =  new Thread(r);
    			t.start();
    		}	
    		System.out.println("等待其他线程工作完成");
    		cdl.await();
    		System.out.println("工作已完成，继续下一步");		
    	}
    	@Override
    	public  void run() { 
    		try { 
    			System.out.println(Thread.currentThread()+"获得生产任务");
    			Thread.currentThread().sleep(1000);
    			System.out.println(Thread.currentThread().getName()+"运行完毕");
    			cdl.countDown();
    		} catch (InterruptedException e) { 
    			e.printStackTrace();
    		}
    	}	
    }

# 3.CyclicBarrier #

CyclicBarrier，字面意思循环屏障，和CountDownLatch有点相似，只不过CountDownLatch是一个线程等待着其他线程完成后再进行执行，CyclicBarrier是用来表明一组线程全部都达到Barrier状态后再一起向下执行，有种好像好兄弟要走一起走的赶脚，且可以多个线程组进行重用。

*  构造方法  
    通过构造方法来申明好兄弟的数量，parties表示数量，Runnable barrierAction 参数为runnable，当所有的线程都到达Barrier状态后，会选择其中一个进行运行该runnable。

public CyclicBarrier(int parties, Runnable barrierAction) { }
    public CyclicBarrier(int parties) { }

*  关键方法  
    将线程的状态设置为Barrier，可设置最长的等待时间，若没有，则抛出一个异常继续向下执行。

public int await() throws InterruptedException, BrokenBarrierException { }
    public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException {

*  简单DEMO

public class test1 implements Runnable{ 
    	private static CyclicBarrier ccb = new CyclicBarrier(3);
    	public static void main(String[] args) throws InterruptedException { 
    		Runnable r = new test1();
    		for(int i=0;i<3;i++) { 
    			Thread t =  new Thread(r);
    			t.start();
    		}
    	}
    	@Override
    	public  void run() { 
    		try { 
    			System.out.println(Thread.currentThread()+"获得生产任务");
    			Thread.currentThread().sleep(1000);
    			System.out.println(Thread.currentThread().getName()+"生产完毕，在线等待其他线程生产完毕");
    			ccb.await();
    			System.out.println(Thread.currentThread().getName()+"继续向下生产");
    		} catch (InterruptedException e) { 
    			e.printStackTrace();
    		}
    		catch (BrokenBarrierException e) { 
    			e.printStackTrace();
    		}
    	}	
    }