经过源码和实例学习CountDownLatch类

透过源码和实例学习CountDownLatch类

最近在做一个程序的时候遇到了这样的情况，在主类中需要执行一些操作，同时主类会启动几个线程，在这些线程执行前和执行后都会一系列的操作。因此就用到了CountDownLatch类。CountDownLatch是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

下边是一个例子：

import mulithread.CountDownLatch;

class Driver {  
	public static void main(String []args) throws InterruptedException {
		CountDownLatch startSignal = new CountDownLatch(1,"startsignal");
		CountDownLatch doneSignal = new CountDownLatch(2,"endsignal");
		
		for (int i = 0; i < 2; ++i)
			new Thread(new Worker(startSignal, doneSignal,i)).start();// create and start threads
		Thread.sleep(3000);
		System.out.println("don't let run yet"); //don't let run yet
		startSignal.countDown(); //let all threads proceed
		doneSignal.await(); // wait for all to finish
		System.out.println("wait for all to finish");
	}
}

import mulithread.CountDownLatch;


class Worker implements Runnable {
	private final CountDownLatch startSignal;
	private final CountDownLatch doneSignal;
	private int threadid;
	Worker(CountDownLatch startSignal, CountDownLatch doneSignal,int threadid) {
		this.startSignal = startSignal;
		this.doneSignal = doneSignal;
		this.threadid=threadid;
	} 

	public void run() {
		try {
			System.out.println(threadid+"before process");
			startSignal.await();//所有调用 await 的线程都一直在入口处等待
			doWork();
			doneSignal.countDown();
			System.out.println(threadid+"after process");
		} catch (InterruptedException ex) {
		
		}  
	}

	void doWork() {
		try {
			Thread.sleep(20);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(threadid+"runing----------");
	}
}

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;

public class CountDownLatch {
	
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;

        Sync(int count) {
            setState(count);
        }

        int getCount() {
            return getState();
        }

        public int tryAcquireShared(int acquires) {
            return getState() == 0? 1 : -1;
        }

        public boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }
    private String name;
    private final Sync sync;

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

    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    	System.out.println(name+" await invoked!"+getCount());
    }
    public boolean await(long timeout, TimeUnit unit)
        throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

    public void countDown() {
        sync.releaseShared(1);
        System.out.println(name+" count down invoked!"+getCount());
    }
    public long getCount() {
        return sync.getCount();
    }

    public String toString() {
        return super.toString() + "[Count = " + sync.getCount() + "]";
    }
}

注意，有三个类，其中Driver是主类，Worker类是要工作时候用到的线程，CountDownLatch类值从java源代码抠出来的，只是做了一些状态输出工作。在这个例子中，有两个工作线程，所有的线程在工作之前(dowork方法完成工作任务)startSignal的await()方法会一直阻塞，直到主类中startSignal的countDown()执行之后才会执行。同样的，在所有工作完成之前，主类中doneSignal的await()方法会一直阻塞，一直到doneSignal的所有线程的 countdown方法会被调用，使得计数器的值递减，从而后边的代码才会执行。这个例子其实简单而言描述这样一个场景:主类中如果有几个线程，但是这些线程又必须在主类中的一些操作完成之前才可以执行，那么就可以把代码放在主类的startSignal的countdown()方法之上，同样，如果想要在所有线程执行之后，做一些工作，那么就可以把代码放在doneSignal的await()方法之后执行。至于CountDownLatch 中的参数，其实就是计数器的值，看你的具体需求情况啦！

经过源码和实例学习CountDownLatch类

相关推荐