java并发包中CountDownLatch和线程池的使用详解

Java并发包中的CountDownLatch和线程池是常用的并发编程工具，其使用详解如下：

CountDownLatch

介绍

CountDownLatch是一个计数器，用来控制一个或多个线程等待多个线程的执行完成。CountDownLatch的构造方法接收int类型的参数，该参数就是计数器的初始值。当一个线程完成自己的任务后，计数器的值就会减1，当计数器的值为0时，表示所有等待的线程都已经完成任务，可以继续执行后续的操作了。

使用场景

CountDownLatch适用于一些需要等待其它线程完成某些操作之后才能继续执行操作的场景，比如在主线程中等待所有子线程执行完成后执行某个操作。

示例1

下面是一个使用CountDownLatch的示例代码，其中有5个线程分别进行不同计算任务，主线程需要等待所有线程执行完成后，才能统计计算结果:

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        final int threadNum = 5;
        final CountDownLatch latch = new CountDownLatch(threadNum);
        for (int i = 0; i < threadNum; i++) {
            new Thread(() -> {
                // 模拟处理
                System.out.println(Thread.currentThread().getName() + " started");
                try {
                    Thread.sleep(2000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " ended");
                // 完成任务，计数器减1
                latch.countDown();
            }).start();
        }
        // 等待所有线程执行完成
        latch.await();
        System.out.println("All threads have completed");
    }
}

示例2

下面是另一个使用CountDownLatch的示例代码，其中主线程需要等待两个子线程执行完成后才能继续执行后面的操作：

public class CountDownLatchExample2 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(2);
        new Thread(() -> {
            try {
                Thread.sleep(3000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 1 executed");
            countDownLatch.countDown();
        }).start();
        new Thread(() -> {
            try {
                Thread.sleep(2000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 executed");
            countDownLatch.countDown();
        }).start();
        countDownLatch.await();
        System.out.println("All threads have completed");
    }
}

线程池

介绍

线程池是一个可以重复利用线程的线程集合，可以避免线程的创建和销毁带来的开销。Java中的线程池是通过ThreadPoolExecutor实现的。

使用场景

线程池适用于需要频繁创建和销毁线程的场景，比如高并发的网络请求处理，多线程文件处理等。

示例1

下面是一个使用线程池的示例代码，其中我们通过ThreadPoolExecutor创建一个线程池，然后提交多个任务：

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(2);
        for (int i = 0; i < 5; i++) {
            int index = i + 1;
            threadPool.execute(() -> {
                System.out.println("Task " + index + " is being executed by " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Task " + index + " has been completed.");
            });
        }
        threadPool.shutdown();
    }
}

示例2

下面是另一个使用线程池的示例代码，其中我们创建一个ScheduledThreadPoolExecutor来执行定时任务：

public class ScheduledThreadPoolExample {
    public static void main(String[] args) {
        ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(2);
        threadPool.scheduleAtFixedRate(() -> {
            System.out.println("Task1 is being executed by " + Thread.currentThread().getName() + " at " + new Date());
        }, 0L, 2L, TimeUnit.SECONDS);
        threadPool.scheduleAtFixedRate(() -> {
            System.out.println("Task2 is being executed by " + Thread.currentThread().getName() + " at " + new Date());
        }, 0L, 4L, TimeUnit.SECONDS);
        // threadPool.shutdown();
    }
}

以上是CountDownLatch和线程池的详细使用攻略，希望对您有所帮助。