JUC同步工具CountDownLatch

CountDownLatch：允许一条或多条线程等待其它线程中的一组操作完成后再继续执行。

 

在探究CountDownLatch之前，我们知道Thread的join也有类似功能，先看thread的join方法：

public static void main(String[] args) throws InterruptedException{
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("i am t1");
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    t1.join();
                }
                catch (InterruptedException e){}
                System.out.println("i am t2");
            }
        });
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    t2.join();
                }
                catch (InterruptedException e){}
                System.out.println("i am t3");
            }
        });
        t1.start();
        t2.start();
        t3.start();
    }

 

 Thread join方法原理：

 

 源码中，可以看到join调用了Object的wait方法，是一个无限等待。

疑问：既然这里有wait，那notify去哪了？ 

原来在jvm源码中有这样一句：

// 位于/hotspot/src/share/vm/runtime/thread.cpp中
void JavaThread::exit(bool destroy_vm, ExitType exit_type) {
    // ...

    // Notify waiters on thread object. This has to be done after exit() is called
    // on the thread (if the thread is the last thread in a daemon ThreadGroup the
    // group should have the destroyed bit set before waiters are notified).
    // 看这里
    ensure_join(this);

    // ...
}


static void ensure_join(JavaThread* thread) {
    // We do not need to grap the Threads_lock, since we are operating on ourself.
    Handle threadObj(thread, thread->threadObj());
    assert(threadObj.not_null(), "java thread object must exist");
    ObjectLocker lock(threadObj, thread);
    // Ignore pending exception (ThreadDeath), since we are exiting anyway
    thread->clear_pending_exception();
    // Thread is exiting. So set thread_status field in  java.lang.Thread class to TERMINATED.
    java_lang_Thread::set_thread_status(threadObj(), java_lang_Thread::TERMINATED);
    // Clear the native thread instance - this makes isAlive return false and allows the join()
    // to complete once we've done the notify_all below
    java_lang_Thread::set_thread(threadObj(), NULL);

    // 看这里
    lock.notify_all(thread);

    // Ignore pending exception (ThreadDeath), since we are exiting anyway
    thread->clear_pending_exception();
}

 

回到CountDownLatch：

使用：

public static void main(String[] args) throws InterruptedException{
        CountDownLatch c2 = new CountDownLatch(1);//t2使用
        CountDownLatch c3 = new CountDownLatch(1);//t3使用
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("i am t1");
                c2.countDown();
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    c2.await();
                }
                catch (InterruptedException e){}
                System.out.println("i am t2");
                c3.countDown();
            }
        });
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    c3.await();
                }
                catch (InterruptedException e){}
                System.out.println("i am t3");
            }
        });
        t1.start();
        t2.start();
        t3.start();
    }

CountDownLatch原理：

利用AQS，主线程（需要等待其它线程的线程）进入AQS队列中等待，前置线程通过State获取锁并执行任务，当State=0时即表示任务全部执行完毕。主线程唤醒。

await()方法 ==》

主线程入队等待：LockSupport.park()

 

countDown方法 ==》分成两步：

1，前置线程执行完释放锁，State-1；

2，一旦State=0，唤醒主线程。

 

 

可以看到，CountDownLatch更加灵活，Join方法必须等待前置线程执行完毕才能开始执行下一线程，中间过程无法控制；

而CountDownLatch的countDown方法可以自由的对任务片段进行控制。