java 信号量 countdown_利用信号量模拟CountDownLatch

CountDownLatch

CountDownLatch是一个同步工具类，用来协调多个线程之间的同步

CountDownLatch能够使一个线程等待另一些线程完成各自任务之后，再执行。

CountDownLatch实现

这个地方mutexLock是一个用信号量构造的互斥锁，主要是保护共享变量的。详见 利用信号量来实现读写锁

构造函数接受一个整数。是一个计数器。

这个latch设置信号量的初始值是0。这样当A线程运行await函数时，他就会立即阻塞。

当其他线程运行down函数(相对于CountDownLatch中的countdown函数)count就减减，直到count等于0时。表明所有线程执行完毕。就释放锁。唤醒A线程。

public class MyCountDownLatch {

private Semaphore latch = new Semaphore(0);

private MutexLock mutex = new MutexLock();

private int count;

MyCountDownLatch(int i){

count = i;

}

public void await() throws InterruptedException{

latch.acquire();

}

public void down() throws InterruptedException {

mutex.lock();

count--;

if(count == 0){

latch.release();

}

mutex.unlock();

}

}

测试代码

public class Main {

public static void main(String[] args){

new Main().test();

}

private void test(){

int num = 5;

MyCountDownLatch latch = new MyCountDownLatch(num);

for(Integer i = 0; i < num; i++){

new MyThread(latch,i.toString()).start();

}

try {

latch.await();

}catch (Exception e){

}

System.out.println("all done");

}

class MyThread extends Thread{

private MyCountDownLatch latch;

public MyThread(MyCountDownLatch l,String name){

latch = l;

this.setName(name);

}

public void run(){

try{

System.out.println(this.getName() + " is running");

Thread.sleep((int)(Math.random() * 5000));

System.out.println(this.getName() + " done");

latch.down();

}catch (Exception e){

}

}

}

}

测试的结果

0 is running

3 is running

1 is running

2 is running

4 is running

2 done

0 done

1 done

4 done

3 done

all done