java多线程(3)之join与countDownLatch

---

join是Thread中的类,一般用于一个A线程需要等到另一个B线程的结果才可以继续执行的情形, 这是一种有序的执行方式,比如说主线程需要等到子线程返回的结果后才可以继续执行.
eg.

public class TestThread extends Thread {    public TestThread(String name) {        super(name);    }    @Override    public void run() {        try {            for (int i=0;i<5;i++) {                System.out.println(Thread.currentThread().getName()+":"+i);            }        } catch (Exception e) {        }    }}public class MultThreadTest {    @Test    public void test() {        TestThread testThread1 = new TestThread("线程111111");        testThread1.start();        try {            testThread1.join();        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println(Thread.currentThread().getName() + ":执行结束");    }}

实现起来比较简单,调用testThread1.join()方法后,输出”执行结束”的语句需要等到testThread1线程执行完毕后才可以执行。如果把testThread1.join()去掉后就变成并发执行了。

thread.join源码解析

 public final void join() throws InterruptedException {        join(0);    }     /**     * Waits at most {@code millis} milliseconds for this thread to     * die. A timeout of {@code 0} means to wait forever.     *     * <p> This implementation uses a loop of {@code this.wait} calls     * conditioned on {@code this.isAlive}. As a thread terminates the     * {@code this.notifyAll} method is invoked. It is recommended that     * applications not use {@code wait}, {@code notify}, or     * {@code notifyAll} on {@code Thread} instances.     *     * @param  millis     *         the time to wait in milliseconds     *     * @throws  IllegalArgumentException     *          if the value of {@code millis} is negative     *     * @throws  InterruptedException     *          if any thread has interrupted the current thread. The     *          <i>interrupted status</i> of the current thread is     *          cleared when this exception is thrown.     */    public final void join(long millis) throws InterruptedException {        synchronized(lock) {        long base = System.currentTimeMillis();        long now = 0;        if (millis < 0) {            throw new IllegalArgumentException("timeout value is negative");        }        if (millis == 0) {            while (isAlive()) {                lock.wait(0);            }        } else {            while (isAlive()) {                long delay = millis - now;                if (delay <= 0) {                    break;                }                lock.wait(delay);                now = System.currentTimeMillis() - base;            }        }        }    }

执行到if (millis == 0) {
while (isAlive()) {
lock.wait(0);
}
}里面做了两件事:判断线程是否存活,另外执行了lock.wait(0)方法进行阻塞，需等待到notify/notifyAll调用时才可以继续执行,然而notify()/notifyAll()方法什么时候执行的呢?

>

This implementation uses a loop of {@code this.wait} calls * conditioned on {@code this.isAlive}. As a thread terminates the * {@code this.notifyAll} method is invoked. It is recommended that * applications not use {@code wait}, {@code notify}, or * {@code notifyAll} on {@code Thread} instances.

这里的说明是说当线程停止的时候会调用notifyAll()方法,并且不推荐我们应用程序中的线程实例自身调用wait/notify/notifyAll()方法.这里就说明了当testThread1线程的run()方法执行结束的时候，会解除阻塞继续执行下去，执行到主线程，从而实现了线程间的有序执行。

---

countDownLatch的作用跟join差不多,也可以用来实现线程间协调工作,它的原理是利用“锁计数器”实现的,里面用到了CAS设计。如果完成一个工作需要n个线程并发执行,互不干扰,当这n个任务都完成后才能执行后续的操作,这时就可以设置锁计数器的个数为n，每完成一个任务锁计数器就减1，直到锁计数器为0所有任务完成后才继续执行后续的操作。这就是countDownLatch的原理

eg.

public class TestThread extends Thread {    CountDownLatch latch;    public TestThread(String name, CountDownLatch countDownLatch) {        super(name);        latch=countDownLatch;    }    @Override    public void run() {        try {            for (int i = 0; i < 5; i++) {                System.out.println(Thread.currentThread().getName() + ":" + i+"执行结束,锁计数器减1");            }            latch.countDown();        } catch (Exception e) {        }    }}public class MultThreadTest {    CountDownLatch countDownLatch;    int tasks;    @Before    public void setUp(){        tasks=3;        countDownLatch=new CountDownLatch(tasks);    }    @Test    public void test() {        for (int i=0;i<tasks;i++){            TestThread testThread = new TestThread("线程"+i+"执行",countDownLatch);            testThread.start();        }        try {            System.out.println(Thread.currentThread().getName()+":等待执行");            countDownLatch.await();            System.out.println(Thread.currentThread().getName() + ":执行结束");        }catch (InterruptedException e){            e.printStackTrace();        }    }}

latch.countDown();每执行一次锁计数器减1，当锁计数器为0时,countDownlatch.await()不再阻塞，锁计数器大于0时会阻塞下去.

---

countDownLatch源码解析

countDownLatch构造函数:

 public CountDownLatch(int count) {       if (count < 0) throw new IllegalArgumentException("count < 0");        this.sync = new Sync(count);    } private static final class Sync extends AbstractQueuedSynchronizer {        private static final long serialVersionUID = 4982264981922014374L;        Sync(int count) {            setState(count);        }        int getCount() {            return getState();        }

构造函数中创建了Sync对象,Sync继承了AQS,这是countDownlatch核心实现!

countDownLatch instance中的countDown调用关系.

 public void countDown() {        sync.releaseShared(1);    }    public final boolean releaseShared(int arg) {        if (tryReleaseShared(arg)) {            doReleaseShared();            return true;        }        return false;    }     protected int tryAcquireShared(int acquires) {            return (getState() == 0) ? 1 : -1;        }        protected 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 void doReleaseShared() {           for (;;) {            Node h = head;            if (h != null && h != tail) {                int ws = h.waitStatus;                if (ws == Node.SIGNAL) {                    if (!h.compareAndSetWaitStatus(Node.SIGNAL, 0))                        continue;        // loop to recheck cases                    unparkSuccessor(h);                }                else if (ws == 0 &&                         !h.compareAndSetWaitStatus(0,Node.PROPAGATE))                    continue;           // loop on failed CAS            }            if (h == head)             // loop if head changed                break;        }    }

tips: tryReleaseShared()方法中for(;;)采用的自旋方法来比较设置compareAndSetState(),这是很常见的CAS方式java多线程(二)之CAS操作.countDownLatch每执行一次countDown()，就会不断的尝试释放锁, compareAndSetState执行成功,就会修改一次锁计数减1，当锁计数器为0时执行doReleaseShared()，唤醒后面队列中的的节点线程。

countDownLatch instance中的await()调用关系.

public void await() throws InterruptedException {        sync.acquireSharedInterruptibly(1);    }    public final void acquireSharedInterruptibly(int arg)            throws InterruptedException {        if (Thread.interrupted())            throw new InterruptedException();        if (tryAcquireShared(arg) < 0)            doAcquireSharedInterruptibly(arg);    }    protected int tryAcquireShared(int acquires) {            return (getState() == 0) ? 1 : -1;        }    private void doAcquireSharedInterruptibly(int arg)        throws InterruptedException {        final Node node = addWaiter(Node.SHARED);        try {            for (;;) {                final Node p = node.predecessor();                if (p == head) {                    int r = tryAcquireShared(arg);                    if (r >= 0) {                        setHeadAndPropagate(node, r);                        p.next = null; // help GC                        return;                    }                }                if (shouldParkAfterFailedAcquire(p, node) &&                    parkAndCheckInterrupt())                    throw new InterruptedException();            }        } catch (Throwable t) {            cancelAcquire(node);            throw t;        }    }   ... 

进入到doAcquireSharedInterruptibly(arg)方法进行等待,当getState()==0时结束，countDownLatch()后面的语句继续执行.countDownLatch类大致的源码调用流程分析完了，有什么不足欢迎大家在下方留言指正，不胜感激.

---