CountDownLatch源码解析

待我称王封你为后i 2023-07-12 08:52 14阅读 0赞

## 1. 首先看一下CountDownLatch的构造函数 ##

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

然后看一下Sync类，是一个静态内部类，继承了AQS，重写了`tryAcquireShared()`与`tryReleaseShared()`两个共享的方法

private static final class Sync extends AbstractQueuedSynchronizer { 
            private static final long serialVersionUID = 4982264981922014374L;
    
            Sync(int count) { 
                setState(count);
            }
    
            int getCount() { 
                return getState();
            }
    
            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;
                }
            }
        }

构造对象时，传入state初始值

## 2. 看一下countDown()方法 ##

public void countDown() { 
            	sync.releaseShared(1);
        	}

countDown时会把state-1，看一下releaseShared()方法的实现

public final boolean releaseShared(int arg) { 
            if (tryReleaseShared(arg)) { 
                doReleaseShared();
                return true;
            }
            return false;
        }

`tryReleaseShared()`为内部类实现，如果state = state-1设置成功，并且state为0时返回true，为true时调用了`doReleaseShared()`方法。介绍完await()方法再介绍此方法

## 3. 看一下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);
        }

await方法中获取1个状态，最终调用内部类实现的`tryAcquireShared()`方法，此方法只有在state==0时才返回1，否则返回-1（返回-1表示state>0，也就是计数没有用完），调用`doAcquireSharedInterruptibly()`方法，看一下此方法

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;
            }
        }

`addWaiter()`方法表示增加一个新Node节点到等待队列尾部，并返回这个新节点。当执行到`tryAcquireShared()`方法时，若state!=0，返回-1，后面会进入`parkAndCheckInterrupt()`方法等待

private final boolean parkAndCheckInterrupt() { 
            LockSupport.park(this);
            return Thread.interrupted();
        }

## 4. 下面看一下doReleaseShared()方法 ##

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;
            }
        }

看一下`unparkSuccessor()`方法

private void unparkSuccessor(Node node) { 
            int ws = node.waitStatus;
            if (ws < 0)
                node.compareAndSetWaitStatus(ws, 0);
    
            Node s = node.next;
            if (s == null || s.waitStatus > 0) { 
                s = null;
                for (Node p = tail; p != node && p != null; p = p.prev)
                    if (p.waitStatus <= 0)
                        s = p;
            }
            if (s != null)
                LockSupport.unpark(s.thread);
        }

`unparkSuccessor()`方法会唤醒等待的线程，正好唤醒上面`await()`方法park的线程

## 5. 总结 ##

利用AQS的state表示计数值，每次调用countDown()方法时会减一，当减到0时会唤醒await()方法等待的线程。

**实时内容请关注微信公众号，公众号与博客同时更新：程序员星星**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTIzMjY0NjI_size_16_color_FFFFFF_t_70]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTIzMjY0NjI_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200307132829764.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTIzMjY0NjI=,size_16,color_FFFFFF,t_70