JUC 简介

什么是JUC？

JUC（java.util.concurrent）是Java并发编程工具包，提供了丰富的并发编程工具类。

主要内容

1. 线程基础

• Thread类与Runnable接口
• 线程的生命周期
• 线程的创建与启动

2. 并发工具

• Lock接口：比synchronized更灵活的锁机制
• 线程池：管理和复用线程
• 并发容器：线程安全的集合类
• 同步工具：CountDownLatch、CyclicBarrier、Semaphore等

3. 原子类

提供无锁的线程安全操作：

• AtomicInteger
• AtomicLong
• AtomicReference

为什么需要JUC？

传统synchronized的局限

// synchronized的局限性
synchronized(obj) {
    // 1. 无法中断等待
    // 2. 无法设置超时
    // 3. 无法实现公平锁
}

JUC的优势

// ReentrantLock提供更多功能
Lock lock = new ReentrantLock();
try {
    lock.lock();
    // 业务代码
} finally {
    lock.unlock();
}

// 可中断、可超时、可公平
if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try {
        // 业务代码
    } finally {
        lock.unlock();
    }
}

JUC核心组件

1. Executor框架

ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(() -> {
    System.out.println("任务执行");
});
executor.shutdown();

2. Lock接口

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();

3. 并发容器

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
BlockingQueue<String> queue = new LinkedBlockingQueue<>();

4. 原子操作类

AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet();  // 原子自增
count.compareAndSet(1, 2);  // CAS操作

5. 同步工具类

// CountDownLatch：倒计时门闩
CountDownLatch latch = new CountDownLatch(3);
latch.countDown();
latch.await();

// CyclicBarrier：循环屏障
CyclicBarrier barrier = new CyclicBarrier(3);
barrier.await();

// Semaphore：信号量
Semaphore semaphore = new Semaphore(3);
semaphore.acquire();
semaphore.release();

并发编程三大特性

1. 原子性（Atomicity）

操作不可分割，要么全部执行，要么全不执行。

AtomicInteger i = new AtomicInteger(0);
i.incrementAndGet();  // 原子操作

2. 可见性（Visibility）

一个线程修改的共享变量，其他线程能立即看到。

volatile int count = 0;  // 保证可见性

3. 有序性（Ordering）

程序执行的顺序按照代码的先后顺序执行。

// volatile禁止指令重排序
volatile boolean flag = false;

线程安全问题示例

问题代码

public class Counter {
    private int count = 0;
    
    public void increment() {
        count++;  // 非原子操作，线程不安全
    }
}

解决方案

// 方案1：synchronized
public synchronized void increment() {
    count++;
}

// 方案2：Lock
private Lock lock = new ReentrantLock();
public void increment() {
    lock.lock();
    try {
        count++;
    } finally {
        lock.unlock();
    }
}

// 方案3：原子类
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
    count.incrementAndGet();
}

💡 提示

这是一个demo文档，欢迎补充更多JUC相关内容。

深入学习

• 线程基础
• 并发工具详解