闭锁CountDownLatch与栅栏CyclicBarrier

逃离我推掉我的手 2022-06-10 02:22 249阅读 0赞

一、闭锁与栅栏介绍(jdk1.5)

**闭锁(CountDownLatch)** **:**在并发时的同步辅助类，在一组线程正在完成某个任务之前，允许一个或多个线程一直等待。即 一组线程等待某一事件发生，事件没有发生前，所有线程将阻塞等待；而事件发生后，所有线程将开始执行；闭锁最初处于封闭状态，当事件发生后闭锁将被打开，一旦打开，闭锁将永远处于打开状态。

**栅栏(CyclicBarrier)：**在并发时的同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点。利用栅栏，可以使线程相互等待，直到所有线程都到达某一点，然后栅栏将打开，所有线程将通过栅栏继续执行CyclicBarrier支持一个可选的Runnable 参数，当线程通过栅栏时，runnable对象将被调用。构造函数CyclicBarrier(int parties,Runnable barrierAction)，当线程在CyclicBarrier对象上调用await()方法时，栅栏的计数器将增加1，当计数器为parties时，栅栏将打开。

区别：闭锁用于所有线程等待一个外部事件的发生；栅栏则是所有线程相互等待，直到所有线程都到达某一点时才打开栅栏，然后线程可以继续执行。

二、 闭锁与栅栏实例

1、闭锁

假定有这么个场景:有三个工人在为老板干活，这个老板有一个习惯，就是当三个工人把一天的活都干完了的时候，他就来检查所有工人所干的活。记住这个条件：三个工人先全部干完活，老板才检查。所以在这里用Java代码设计两个类，Worker代表工人，Boss代表老板，具体的代码实现如下：

package com.studyproject.lock;
    
    import java.util.Random;
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    
    /***
     * 
     * 闭锁(一个线程去等待其它线程做完所有之后再去做其它的事情)
     * */
    public class TestLatch {
    	public static void main(String[] args) {
    		ExecutorService executor = Executors.newCachedThreadPool();
    		CountDownLatch latch = new CountDownLatch(3);
    		Work w1 = new Work(latch, "张三");
    		Work w2 = new Work(latch, "李四");
    		Work w3 = new Work(latch, "王二");
    		Boss boss = new Boss(latch);
    		executor.execute(w3);
    		executor.execute(w2);
    		executor.execute(w1);
    		executor.execute(boss);
    		executor.shutdown();
    	}
    
    }
    
    class Work implements Runnable {
    	private CountDownLatch downLatch;
    	private String name;
    
    	public Work(CountDownLatch downLatch, String name) {
    		this.downLatch = downLatch;
    		this.name = name;
    	}
    
    	@Override
    	public void run() {
    
    		System.out.println(this.name + "正在干活!");
    		try {
    			TimeUnit.SECONDS.sleep(new Random().nextInt(10));
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    
    		System.out.println(this.name + "活干完了！");
    		this.downLatch.countDown();
    	}
    
    }
    
    class Boss implements Runnable {
    	private CountDownLatch downLatch;
    
    	public Boss(CountDownLatch downLatch) {
    		this.downLatch = downLatch;
    	}
    
    	@Override
    	public void run() {
    
    		System.out.println("老板正在等所有的工人干完活......");
    		try {
    			this.downLatch.await();
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    
    		System.out.println("工人活都干完了，老板开始检查了！");
    	}
    }

2、栅栏

假定场景：三个工人，他们三个合作建桥，有三个桩，每人打一个，同时打完之后才能一起搭桥（搭桥需要三人一起合作）。也就是说三个人都打完桩之后才能继续工作。实现如下：

package com.studyproject.lock;
    
    import java.util.concurrent.CyclicBarrier;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * 
     * 栅栏<br>
     * 三个工人，他们三个合作建桥，有三个桩，每人打一个，同时打完之后才能一起搭桥（搭桥需要三人一起合作）。也就是说三个人都打完桩之后才能继续工作
     * */
    public class CycTest {
    	public static void main(String[] args) {
    		ExecutorService executorpool = Executors.newFixedThreadPool(3);
    		CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
    		CycWork work1 = new CycWork(cyclicBarrier, "张三");
    		CycWork work2 = new CycWork(cyclicBarrier, "李四");
    		CycWork work3 = new CycWork(cyclicBarrier, "王五");
    		executorpool.execute(work1);
    		executorpool.execute(work2);
    		executorpool.execute(work3);
    		executorpool.shutdown();
    	}
    }
    
    class CycWork implements Runnable {
    	private CyclicBarrier cyclicBarrier;
    	private String name;
    
    	public CycWork(CyclicBarrier cyclicBarrier, String name) {
    		this.name = name;
    		this.cyclicBarrier = cyclicBarrier;
    	}
    
    	@Override
    	public void run() {
    		System.out.println(name + "正在打桩，毕竟不轻松。。。。。");
    		try {
    			Thread.sleep(5000);
    			System.out.println(name + "不容易，终于把桩打完了。。。。");
    			cyclicBarrier.await();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    
    		System.out.println(name + "：其他逗b把桩都打完了，又得忙活了。。。");
    
    	}
    
    }

三、实现原理分析

1、闭锁原理：

CountDown类中主要有三个方法:

a、构造函数

public CountDownLatch(int count) {
            if (count < 0) throw new IllegalArgumentException("count < 0");
            this.sync = new Sync(count);
     }

b、对计数器减一

public void countDown() {    //对计数器减一，表示有一个事件已经发生了
            sync.releaseShared(1); 
       }

c、等到计数器为0

public void await() throws InterruptedException { //等到计数器为0
            sync.acquireSharedInterruptibly(1);
    }

其中count表示需要等待的线程个数，countDown是对这个值进行减减

2、栅栏原理

CyclicBarrier类中主要有以下三个方法：

a、构造函数

public CyclicBarrier(int parties) {
            this(parties, null);
     }

parties主是执行任务的线程个数，内部会赋值给count

b、等待其他任务进行，直到所有任务都结束

public int await() throws InterruptedException, BrokenBarrierException {
            try {
                return dowait(false, 0L);
            } catch (TimeoutException toe) {
                throw new Error(toe); // cannot happen;
            }
        }

其中doWait方法中不停对Index赋值，当index == 0 时

final Runnable command = barrierCommand; 其实是可以设置的，这个Runnable可以传进来，当我们希望所有线程都达到某一时刻之后，用什么线程执行接下来的工作，当没有传Runnable进来时，就继续执行(唤醒其他线程)，否则就runnable.run()（唤醒其他线程之前执行）