 包的简称，它提供了强大的并发编程工具，帮助开发者高效处理多线程环境下的任务。该包于 Java 5 中引入，由 Doug Lea 等专家设计，旨在解决传统线程 API（如 

）的局限性，例如线程创建开销大、资源竞争激烈等。JUC 包含线程池、锁、同步器、原子变量、阻塞队列等组件，使并发编程更安全、高效和可扩展。

在多核 CPU 时代，并发编程已成为提升应用性能的关键。但传统方式存在问题：

JUC 通过抽象层（如 Executor）管理线程生命周期，提供非阻塞算法和高性能数据结构，显著提高并发效率。适用于 Web 服务器、并行计算、消息队列等场景。

Executor 框架是 JUC 的基石，用于 decoupling 任务提交与执行。它定义了 

示例：创建一个固定大小的线程池。

jimport java.util.concurrent.*;

public class ThreadPoolExample { 

    public static void main(String[] args) { 
        // 创建线程池：5 个核心线程，无界队列（LinkedBlockingQueue） 
        ThreadPoolExecutor executor = new ThreadPoolExecutor( 
            5,  // corePoolSize 
            10, // maximumPoolSize 
            0L, TimeUnit.MILLISECONDS, // keepAliveTime 
            new LinkedBlockingQueue<Runnable>(), // workQueue 
            Executors.defaultThreadFactory(), // threadFactory 
            new ThreadPoolExecutor.AbortPolicy() // handler 
        ); 

        // 提交 10 个任务 
        for (int i = 0; i < 10; i++) { 
            final int taskId = i; 
            executor.execute(() -> { 
                System.out.println("Task " + taskId + " executed by " + Thread.currentThread().getName()); 
                try { 
                    Thread.sleep(1000); // 模拟工作 
                } catch (InterruptedException e) { 
                    Thread.currentThread().interrupt(); 
                } 
            }); 
        } 
        executor.shutdown(); // 优雅关闭 
    } 
}

Task 0 executed by pool-1-thread-1
Task 1 executed by pool-1-thread-2
...

），可能导致 OOM。推荐有界队列 + 拒绝策略。

JUC 提供了更灵活的锁，支持公平/非公平、超时获取、可中断等特性。

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample { 

    private int count = 0; 
    private final ReentrantLock lock = new ReentrantLock(); // 默认非公平 

    public void increment() { 
        lock.lock(); // 获取锁 
        try { 
            count++; 
            System.out.println("Count: " + count); 
        } finally { 
            lock.unlock(); // 必须在 finally 中释放 
        } 
    } 

    public static void main(String[] args) { 
        ReentrantLockExample example = new ReentrantLockExample(); 
        Thread t1 = new Thread(() -> { 
            for (int i = 0; i < 5; i++) example.increment(); 
        }); 

        Thread t2 = new Thread(() -> { 
            for (int i = 0; i < 5; i++) example.increment(); 
        }); 

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

 允许多个读者并发，但写者独占。适用于读多写少的场景，如缓存系统。

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample { 

    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock(); 
    private final Lock rLock = rwLock.readLock(); 
    private final Lock wLock = rwLock.writeLock(); 

    private String data = "初始数据"; 

    public String read() { 
        rLock.lock(); 
        try { 
            return data; 
        } finally { 
            rLock.unlock(); 
        } 
    } 

    public void write(String newData) { 
        wLock.lock(); 
        try { 
            data = newData; 
        } finally { 
            wLock.unlock(); 
        } 
    } 
}

JUC 提供了抽象同步器，用于线程间协作。

计数器，线程等待直到计数为 0。适用于“主线程等待子线程完成”。

示例：模拟 3 个工人完成任务后，主线程继续。

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample { 

    public static void main(String[] args) throws InterruptedException { 
        CountDownLatch latch = new CountDownLatch(3); // 计数 3 
        for (int i = 0; i < 3; i++) { 
            final int workerId = i; 
            new Thread(() -> { 
                System.out.println("Worker " + workerId + " working..."); 
                try { 
                    Thread.sleep(1000); 
                } catch (InterruptedException e) { 
                    Thread.currentThread().interrupt(); 
                } 
                latch.countDown(); // 计数 -1 
            }).start(); 
        } 

        latch.await(); // 主线程等待 
        System.out.println("All workers done!"); 
    } 
}

屏障，线程等待直到所有线程到达屏障点，支持重用。适用于“阶段性同步”，如并行计算。

示例：3 个线程共同推进 2 个阶段。

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample { 

    public static void main(String[] args) { 
        CyclicBarrier barrier = new CyclicBarrier(3, () -> { 
            System.out.println("Barrier action executed!"); 
        }); 

        for (int i = 0; i < 3; i++) { 
            final int threadId = i; 
            new Thread(() -> { 
                System.out.println("Thread " + threadId + " phase 1"); 
                try { 
                    barrier.await(); // 等待其他线程 
                } catch (Exception e) { 
                    e.printStackTrace(); 
                } 
                System.out.println("Thread " + threadId + " phase 2"); 
                try { 
                    barrier.await(); 
                } catch (Exception e) { 
                    e.printStackTrace(); 
                } 
            }).start(); 
        } 
    } 
}

信号量，控制并发访问资源数（如数据库连接池）。

示例：允许最多 3 个线程同时访问。

import java.util.concurrent.Semaphore;

public class SemaphoreExample { 

    private final Semaphore semaphore = new Semaphore(3); // 许可数 3 

    public void accessResource() { 
        try { 
            semaphore.acquire(); // 获取许可 
            System.out.println(Thread.currentThread().getName() + " accessing..."); 
            Thread.sleep(1000); 
        } catch (InterruptedException e) { 
            Thread.currentThread().interrupt(); 
        } finally { 
            semaphore.release(); // 释放许可 
        } 
    } 
}

（更灵活的屏障，支持动态线程数）。

原子类基于 CAS（Compare-And-Swap）实现线程安全操作，避免锁开销。常见如 

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample { 

    private static AtomicInteger count = new AtomicInteger(0); 

    public static void increment() { 
        count.incrementAndGet(); // 原子 +1 
    } 

    public static void main(String[] args) throws InterruptedException { 
        Thread[] threads = new Thread[10]; 
        for (int i = 0; i < 10; i++) { 
            threads[i] = new Thread(() -> { 
                for (int j = 0; j < 1000; j++) { 
                    increment(); 
                } 
            }); 
            threads[i].start(); 
        } 

        for (Thread t : threads) t.join(); 
        System.out.println("Final count: " + count.get()); // 始终 10000 
    } 
}

（高并发下性能更好，分段锁）。

6. 阻塞队列：生产者-消费者模式

 是线程安全的队列，支持阻塞操作（

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue; 

public class BlockingQueueExample { 

    public static void main(String[] args) { 
        BlockingQueue<String> queue = new LinkedBlockingQueue<>(10); // 有界 10 
        // 生产者 
        new Thread(() -> { 
            for (int i = 0; i < 5; i++) { 
                try { 
                    queue.put("Item " + i); // 阻塞如果满 
                    System.out.println("Produced: Item " + i); 
                } catch (InterruptedException e) { 
                    Thread.currentThread().interrupt(); 
                } 
            } 
        }).start(); 

        // 消费者 
        new Thread(() -> { 
            for (int i = 0; i < 5; i++) { 
                try { 
                    String item = queue.take(); // 阻塞如果空 
                    System.out.println("Consumed: " + item); 
                } catch (InterruptedException e) { 
                    Thread.currentThread().interrupt(); 
                } 
            } 
        }).start(); 
    } 
}

7. 高级主题：CompletableFuture 和 ForkJoinPool

Java中JUC包介绍与应用

Java JUC 是 Java 标准库中 java.util.concurrent 包的简称，它提供了强大的并发编程工具，帮助开发者高效处理多线程环境下的任务。该包于 Java 5 中引入，由 Doug Lea 等专家设计，旨在解决传统线程 API（如 Thread 和 synchronized）的局限性，例如线程创建开销大、资源竞争激烈等

编程语言

前端

JavaJUC是Java并发编程核心工具包，提供线程池、锁机制、原子操作等高性能并发组件。包含Executor框架、ReentrantLock、CountDownLatch等实用工具，解决传统线程同步的性能瓶颈，适用于多核CPU环境下的高并发场景，显著提升Web服务、并行计算等应用的执行效率。

数据库连接池

消息队列

数据结构

数据库

服务器

Java

4核4G3M云服务器 新用户低至38元/年！

2026新春采购季

message-queue-catalog

tencentdb-catalog

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

Java中JUC包介绍与应用

Java中JUC包介绍与应用

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐