JAVA多线程-CountDownLatch计数器

作者: hu1991die | 来源:发表于2018-05-30 15:31 被阅读29次

一、概述

CountDownLatch是一个同步工具类，它允许一个或多个线程等待其他线程执行完操作之后再继续执行。通常用于控制多个线程的执行顺序。

二、基本原理

我们可以把CountDownLatch看成是一个计数器，其内部维护着一个count计数，计数器的初始化值为需要控制的线程的数量，比如需要控制几个线程顺序执行我们就初始化传入几，之后每当其中一个线程完成了自己的任务后，就调用countDown()来使计数器减1；而在调用者线程中需要调用await()方法使得当前调用者线程一直处于阻塞状态，直至当计数器到达0时，就表明其他所有的线程都已经完成了任务，然后处于阻塞状态的调用者线程才可以继续往下执行。

三、应用场景

假如有这样一个需求，我们当前有一个任务，然后我们把这个任务进行分解成多个步骤完成，这个时候我们可以考虑使用多线程，每个线程完成一个步骤，等到所有的步骤都完成之后，程序提示任务完成。

对于这个需求，通常我们要实现主线程等待所有线程完成任务之后才可继续操作，最为简单的做法是直接使用join()方法，代码如下：

package com.feizi.java.concurrency.tool;

import java.util.concurrent.TimeUnit;

/**
 * Created by feizi on 2018/5/30.
 */
public class JoinTest {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("step one has finished...");
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("step two has finished...");
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("all thread has finished...");
    }
}

控制台输出结果：

step one has finished...
step two has finished...
all thread has finished...

Process finished with exit code 0

join()方法主要用于让当前执行线程等到join线程执行结束才可继续执行。其实现原理就是不停地去检查join线程是否处于存活状态while (isAlive())，如果join线程存活则让当前线程永远wait，我们可以看下源码，wait(0)表示永远等待下去。
join()的源码：

public final void join() throws InterruptedException {
    join(0);
}

继续跟进去：

public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

我们可以看到，重点是这一句，如果存活，就调用wait(0)，使得永远等待。

while (isAlive()) {
    wait(0);
}

直到join线程中止后，线程的this.notifyAll()方法才会被调用，调用notifyAll是在JVM里实现的，所以JDK里看不到。

而在JDK1.5之后的并发包中提供的CountDownLatch也可以实现join的这个功能，并且比join的功能更多。

四、CountDownLatch使用

4.1、例子1-CountDownLatchTest.java类：

package com.feizi.java.concurrency.tool;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * Created by feizi on 2018/5/30.
 */
public class CountDownLatchTest {
    private static CountDownLatch latch = new CountDownLatch(2);

    public static void main(String[] args) throws InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                //步骤一完成
                System.out.println("step one has finished...");
                try {
                    //模拟步骤一耗时操作
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //步骤一完成，调用countDown()方法，计数器就减1
                latch.countDown();

                //步骤二完成
                System.out.println("step two has finished...");
                try {
                    //模拟步骤二耗时操作
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //步骤二完成，调用countDown()方法，计数器就减1
                latch.countDown();
            }
        }).start();

        //步骤一和步骤二完成之前会阻塞住
        latch.await();

        //直到所有的步骤都完成，主线程才继续执行
        System.out.println("all steps have finished...");
    }
}

控制台输出结果：

step one has finished...
step two has finished...
all steps have finished...

Process finished with exit code 0

4.2、例子2-CountDownLatchTest2.java类：

package com.feizi.java.concurrency.tool;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * Created by feizi on 2018/5/30.
 */
public class CountDownLatchTest2 {
    private static CountDownLatch latch = new CountDownLatch(2);

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("step one has finished...");
                    TimeUnit.SECONDS.sleep(1);

                    //计数器减一
                    latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println("step two has finished...");

                    //计数器减一
                    latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t1.start();
        t2.start();
        //计数器清零之前，阻塞住当前线程
        latch.await();

        System.out.println("all steps have finished...");
    }
}

控制台输出结果：

step one has finished...
step two has finished...
all steps have finished...

Process finished with exit code 0

4.3、例子3-CountDownLatchTest3.java类

package com.feizi.java.concurrency.tool;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * Created by feizi on 2018/5/30.
 */
public class CountDownLatchTest3 {

    public static void main(String[] args) throws InterruptedException {
        /*线程计数器*/
        CountDownLatch latch = new CountDownLatch(2);
        Thread t1 = new Thread(new StepOneThread(latch));
        Thread t2 = new Thread(new StepTwoThread(latch));

        t1.start();
        t2.start();

        //调用await()阻塞当前线程，直至计数器清零才可继续执行
        latch.await();
        TimeUnit.SECONDS.sleep(2);
        System.out.println("all steps has finished...");
    }
}

/**
 * 步骤一线程
 */
class StepOneThread implements Runnable{

    private CountDownLatch latch;

    public StepOneThread(CountDownLatch latch) {
        this.latch = latch;
    }

    @Override
    public void run() {
        try {
            System.out.println("step one has finished...");
            //模拟步骤一耗时操作
            TimeUnit.SECONDS.sleep(2);
            //步骤一完成计数器减一
            latch.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/**
 * 步骤二线程
 */
class StepTwoThread implements Runnable{

    private CountDownLatch latch;

    public StepTwoThread(CountDownLatch latch) {
        this.latch = latch;
    }

    @Override
    public void run() {
        try {
            //模拟步骤二耗时操作
            TimeUnit.SECONDS.sleep(2);
            System.out.println("step two has finished...");
            //步骤二完成计数器减一
            latch.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

控制台输出结果：

step one has finished...
step two has finished...
all steps has finished...

Process finished with exit code 0

通过上述简单的例子，我们可以看到CountDownLatch的构造函数接收一个int类型的参数作为计数器count，如果你想等待n个任务完成后再执行，那么这里就直接传入n即可。

当我们调用一次CountDownLatch的countDown()方法时，计数器count便会减1，而CountDownLatch的await()方法则会一直阻塞住当前线程，直至计数器count变为0。

最佳实践：上面所说的n个任务，可以是n个线程（上述例子2和例子3），也可以是1个线程里的n个执行步骤（上述例子1），需要注意的是在运用于多个线程时，我们只需要把这个CountDownLatch的引用传递到线程里即可。

五、其他方法

最后需要注意的是，如果有某个任务特别耗时，而我们又不可能让调用者线程（比如主线程）一直等待下去，那么就可以指定等待的时间，比如这个方法await(long time, TimeUnit unit):此方法在等待指定的时间之后不会再阻塞在当前线程，另外join也有类似的方法。

六、注意

当我们初始化一个CountDownLatch时将其计数器初始化为0，则在调用await()方法时不会阻塞当前线程。比如：

CountDownLatch latch = new CountDownLatch(0);

JAVA多线程-CountDownLatch计数器

一、概述

二、基本原理

三、应用场景

四、CountDownLatch使用

4.1、例子1-CountDownLatchTest.java类：

4.2、例子2-CountDownLatchTest2.java类：

4.3、例子3-CountDownLatchTest3.java类

五、其他方法

六、注意

原文参考

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读