Java多线程CountDownLatch的实现

下面是我对于“Java多线程CountDownLatch的实现”的完整攻略。

CountDownLatch简介

CountDownLatch是JavaSE5中并发包（java.util.concurrent）中的一个类，它可以允许一个线程等待一组线程完成操作后再继续执行。

具体来说，CountDownLatch 常用于某个线程需要等待其它线程执行完毕某些操作后再执行。你可以通过在 CountDownLatch 中指定线程的数量，从而实现让等待线程等待这些线程完成。

CountDownLatch 有两个重要方法：
- countDown()：将 CountDownLatch 的数量减 1。
- await()：让当前线程等待 CountDownLatch 中的数量变为 0。

CountDownLatch实现方式

下面我们通过一个简单的例子来演示如何使用 CountDownLatch。 在这个例子中，我们将创建一个主线程和三个子线程，主线程将等待这三个子线程完成任务后再唤醒继续执行。

import java.util.concurrent.CountDownLatch;
public class Example {
    public static void main(String[] args) throws InterruptedException {
        int count = 3;
        CountDownLatch latch = new CountDownLatch(count);
        for (int i = 0; i < count; i++) {
            Thread thread = new Thread(() -> {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " 结束");
                latch.countDown();
            });
            thread.start();
        }
        System.out.println("等待子线程结束");
        latch.await();
        System.out.println("所有子线程都结束，主线程继续执行");
    }
}

运行上面的代码，你将得到以下输出：

等待子线程结束
Thread-0 结束
Thread-2 结束
Thread-1 结束
所有子线程都结束，主线程继续执行

在上述代码中，我们先创建了一个 CountDownLatch 类型的对象，并将它的计数器初始化为 3。然后我们创建了三个子线程，在每个子线程中模拟完成一个耗时任务（这里我们使用 Thread.sleep 模拟），最后调用 countDown() 方法让计数器减 1。然后在主线程中，我们使用 await() 方法来让主线程阻塞直到 CountDownLatch 中的计数器为 0 。这样主线程才能正常执行前面被阻塞的代码。

下面给出另一个例子，这里我们将使用 CountDownLatch 模拟三个线程协同工作的过程。在这个例子中，我们将随机生成一个数量为 30 的数组，然后让三个线程分别对这个数组的内容进行排序操作。最后我们再将这三个排序后的数组进行归并操作。

import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
public class Example {
    public static void main(String[] args) throws InterruptedException {
        int count = 3;
        CountDownLatch latch = new CountDownLatch(count);
        int[] arr = generateArray(30); // 生成要排序的数组

        int[][] sortedArrs = new int[count][]; // 保存排序后的数组
        for (int i = 0; i < count; i++) {
            final int index = i;
            Thread thread = new Thread(() -> {
                // 对于每个线程，将数组按照元素值升序排序
                Arrays.sort(arr, index * 10, index * 10 + 10);
                sortedArrs[index] = Arrays.copyOfRange(arr, index * 10, index * 10 + 10);
                System.out.println(Thread.currentThread().getName() + "排序完成");
                latch.countDown(); // 线程完成后减少 CountDownLatch 的计数器
            });
            thread.start();
        }
        System.out.println("等待线程排序结束...");
        latch.await();
        System.out.println("所有线程排序操作均已完成");

        // 对排序后的三个数组进行合并操作
        int[] mergedArr = new int[30];
        System.arraycopy(sortedArrs[0], 0, mergedArr, 0, 10);
        System.arraycopy(sortedArrs[1], 0, mergedArr, 10, 10);
        System.arraycopy(sortedArrs[2], 0, mergedArr, 20, 10);
        Arrays.sort(mergedArr);

        System.out.println("合并后的数组：");
        System.out.println(Arrays.toString(mergedArr));
    }

    public static int[] generateArray(int len) {
        int[] arr = new int[len];
        Random random = new Random();
        for (int i = 0; i < len; i++) {
            arr[i] = random.nextInt(100);
        }
        System.out.println("生成的随机数组：");
        System.out.println(Arrays.toString(arr));
        return arr;
    }
}

运行上面的代码，你将得到以下输出：

生成的随机数组：
[70, 70, 82, 8, 35, 91, 80, 97, 46, 37, 44, 89, 50, 91, 48, 5, 70, 17, 24, 77, 43, 54, 37, 21, 67, 46, 45, 3, 73, 79]
等待线程排序结束...
Thread-0排序完成
Thread-2排序完成
Thread-1排序完成
所有线程排序操作均已完成
合并后的数组：
[3, 5, 8, 17, 21, 24, 35, 37, 37, 43, 44, 45, 46, 46, 50, 54, 67, 70, 70, 70, 73, 77, 79, 80, 82, 89, 91, 91, 97]

在上述代码中，我们通过 generateArray 方法生成了一个随机数组（用于排序操作），然后我们创建了三个子线程，每个线程排序数组的不同片段并将排序后的结果保存在 sortedArrs 数组中。每个子线程排序完成后，将会调用 countDown() 方法来使 CountDownLatch 中的计数器减 1。最后，我们在主线程中等待三个子线程排序完成后，对排序后的三个数组进行合并操作。

综上所述，我希望这个完整攻略能帮助你理解和使用 CountDownLatch 类，同时感受到多线程程序设计的魅力。