什么是 JUC？

最新推荐文章于 2025-07-22 23:03:54 发布

原创最新推荐文章于 2025-07-22 23:03:54 发布 · 1.7k 阅读

CC 4.0 BY-SA版权

文章标签：

在 Java 编程领域，随着多核处理器的普及以及对高性能、高并发应用程序需求的增长，多线程编程变得愈发重要。Java 并发包（Java.util.concurrent，简称 JUC）应运而生，它为 Java 开发者提供了一套强大且高效的工具，用于处理多线程编程中的各种复杂问题。本文将深入探讨 JUC 的概念、主要组件及其应用场景。

JUC 概述

JUC 是 Java 5.0 引入的一个包，旨在简化多线程编程并提高其性能和可靠性。它包含了一系列用于并发编程的类和接口，涵盖了线程池、并发集合、同步工具等多个方面，帮助开发者更轻松地编写线程安全且高效的代码。

JUC 主要组件

线程池（ThreadPool）
线程池是 JUC 中一个非常重要的组件，它可以复用已有的线程，减少线程创建和销毁的开销，从而提高系统性能。在 Java 中，通过Executor框架来实现线程池，主要的类有ThreadPoolExecutor和ScheduledThreadPoolExecutor。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池，包含3个线程
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            int taskNumber = i;
            executorService.submit(() -> {
                System.out.println("Task " + taskNumber + " is running on thread " + Thread.currentThread().getName());
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Task " + taskNumber + " has finished");
            });
        }
        // 关闭线程池，不再接受新任务
        executorService.shutdown();
        try {
            // 等待所有任务执行完成
            if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
                executorService.shutdownNow();
                if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
                    System.err.println("Pool did not terminate");
                }
            }
        } catch (InterruptedException ie) {
            executorService.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

在上述代码中，我们创建了一个固定大小为 3 的线程池，提交了 5 个任务。由于线程池大小为 3，同一时间最多有 3 个任务在执行，其余任务会在队列中等待。任务执行完毕后，我们通过shutdown和awaitTermination方法来优雅地关闭线程池。

并发集合（Concurrent Collections）
JUC 提供了多种线程安全的集合类，如ConcurrentHashMap、CopyOnWriteArrayList等。以ConcurrentHashMap为例，它允许多个线程同时读操作，并且在写操作时通过锁分段技术，减少锁的粒度，提高并发性能。

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        map.put("key1", 1);
        map.put("key2", 2);
        // 多个线程可以同时读取
        int value1 = map.get("key1");
        System.out.println("Value for key1: " + value1);
        // 写操作也能在并发环境下高效执行
        map.put("key3", 3);
    }
}

在这段代码中，我们创建了一个ConcurrentHashMap，并进行了读写操作。ConcurrentHashMap内部的设计使得它在多线程环境下能够高效地工作，减少了线程竞争。

同步工具（Synchronization Utilities）
JUC 还包含了一些同步工具类，如CountDownLatch、CyclicBarrier和Semaphore。以CountDownLatch为例，它允许一个或多个线程等待，直到其他线程完成一组操作。

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) {
        int numThreads = 3;
        CountDownLatch latch = new CountDownLatch(numThreads);
        for (int i = 0; i < numThreads; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " is doing some work");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " has finished");
                latch.countDown();
            }).start();
        }
        try {
            // 主线程等待所有子线程完成
            latch.await();
            System.out.println("All threads have finished, main thread can continue");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，我们创建了一个CountDownLatch，初始值为 3。每个子线程完成工作后调用countDown方法，主线程通过await方法等待，直到CountDownLatch的计数为 0，即所有子线程都完成工作。

JUC 的应用场景

高性能服务器：在 Web 服务器、游戏服务器等高性能服务器开发中，线程池可以有效地管理大量的并发请求，提高服务器的响应速度和吞吐量。并发集合则用于存储和管理服务器中的各种数据，确保在多线程环境下数据的一致性和高效访问。
分布式系统：在分布式系统中，同步工具如CountDownLatch和CyclicBarrier可以用于协调多个节点之间的操作。例如，在分布式计算任务中，各个节点完成局部计算后，通过CountDownLatch等待所有节点都完成，然后再进行下一步的汇总操作。