JUC类工具有哪些

Java并发编程是Java开发中的一个重要领域，而java.util.concurrent（简称JUC）包提供了丰富的工具类来简化并发编程的复杂性。JUC包中的类可以分为几大类：锁、原子类、线程池、并发集合、同步工具等。本文将详细介绍JUC包中的主要工具类及其使用场景。

1. 锁（Locks）

1.1 ReentrantLock

ReentrantLock是一个可重入的互斥锁，与synchronized关键字类似，但提供了更灵活的锁机制。ReentrantLock支持公平锁和非公平锁，并且可以尝试获取锁、超时获取锁、中断获取锁等。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private final Lock lock = new ReentrantLock();

    public void performTask() {
        lock.lock();
        try {
            // 临界区代码
        } finally {
            lock.unlock();
        }
    }
}

1.2 ReentrantReadWriteLock

ReentrantReadWriteLock是一种读写锁，允许多个读线程同时访问共享资源，但在写线程访问时，所有读线程和其他写线程都会被阻塞。这种锁适用于读多写少的场景。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReentrantReadWriteLockExample {
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();

    public void readData() {
        rwLock.readLock().lock();
        try {
            // 读取共享资源
        } finally {
            rwLock.readLock().unlock();
        }
    }

    public void writeData() {
        rwLock.writeLock().lock();
        try {
            // 写入共享资源
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

1.3 StampedLock

StampedLock是Java 8引入的一种新的锁机制，提供了三种模式的锁：写锁、悲观读锁和乐观读锁。StampedLock的性能通常优于ReentrantReadWriteLock，尤其是在读多写少的场景下。

import java.util.concurrent.locks.StampedLock;

public class StampedLockExample {
    private final StampedLock stampedLock = new StampedLock();

    public void readData() {
        long stamp = stampedLock.tryOptimisticRead();
        // 读取共享资源
        if (!stampedLock.validate(stamp)) {
            stamp = stampedLock.readLock();
            try {
                // 读取共享资源
            } finally {
                stampedLock.unlockRead(stamp);
            }
        }
    }

    public void writeData() {
        long stamp = stampedLock.writeLock();
        try {
            // 写入共享资源
        } finally {
            stampedLock.unlockWrite(stamp);
        }
    }
}

2. 原子类（Atomic Classes）

原子类提供了一种无锁的线程安全操作，适用于计数器、标志位等场景。JUC包中的原子类包括AtomicInteger、AtomicLong、AtomicBoolean、AtomicReference等。

2.1 AtomicInteger

AtomicInteger是一个可以原子操作的整数类，常用于计数器场景。

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerExample {
    private final AtomicInteger counter = new AtomicInteger(0);

    public void increment() {
        counter.incrementAndGet();
    }

    public int getValue() {
        return counter.get();
    }
}

2.2 AtomicReference

AtomicReference是一个可以原子操作的引用类型，适用于需要原子更新对象的场景。

import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceExample {
    private final AtomicReference<String> reference = new AtomicReference<>("initial");

    public void updateReference(String newValue) {
        reference.set(newValue);
    }

    public String getReference() {
        return reference.get();
    }
}

3. 线程池（Thread Pools）

线程池是管理线程的一种机制，可以有效地控制线程的创建、销毁和复用。JUC包中的ExecutorService接口及其实现类提供了线程池的功能。

3.1 ThreadPoolExecutor

ThreadPoolExecutor是线程池的核心实现类，允许开发者自定义线程池的核心线程数、最大线程数、线程存活时间、任务队列等参数。

import java.util.concurrent.*;

public class ThreadPoolExecutorExample {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                2, // 核心线程数
                4, // 最大线程数
                60, // 线程存活时间
                TimeUnit.SECONDS, // 时间单位
                new LinkedBlockingQueue<>() // 任务队列
        );

        executor.execute(() -> {
            // 执行任务
        });

        executor.shutdown();
    }
}

3.2 Executors

Executors是一个工具类，提供了创建常用线程池的工厂方法，如newFixedThreadPool、newCachedThreadPool、newSingleThreadExecutor等。

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

public class ExecutorsExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(4);

        executor.execute(() -> {
            // 执行任务
        });

        executor.shutdown();
    }
}

4. 并发集合（Concurrent Collections）

JUC包提供了一系列线程安全的集合类，如ConcurrentHashMap、CopyOnWriteArrayList、BlockingQueue等。

4.1 ConcurrentHashMap

ConcurrentHashMap是一个线程安全的哈希表，适用于高并发的场景。与Hashtable相比，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);

        System.out.println(map.get("key1"));
    }
}

4.2 CopyOnWriteArrayList

CopyOnWriteArrayList是一个线程安全的列表，适用于读多写少的场景。每次写操作都会创建一个新的副本，因此读操作不需要加锁。

import java.util.concurrent.CopyOnWriteArrayList;

public class CopyOnWriteArrayListExample {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        list.add("item1");
        list.add("item2");

        for (String item : list) {
            System.out.println(item);
        }
    }
}

4.3 BlockingQueue

BlockingQueue是一个支持阻塞操作的队列，常用于生产者-消费者模型。常见的实现类有ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue等。

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

public class BlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> queue = new LinkedBlockingQueue<>(10);

        // 生产者线程
        new Thread(() -> {
            try {
                queue.put("item1");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        // 消费者线程
        new Thread(() -> {
            try {
                String item = queue.take();
                System.out.println(item);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

5. 同步工具（Synchronizers）

JUC包提供了一些同步工具类，如CountDownLatch、CyclicBarrier、Semaphore、Exchanger等，用于控制多个线程之间的同步。

5.1 CountDownLatch

CountDownLatch是一个同步辅助类，允许一个或多个线程等待其他线程完成操作。CountDownLatch的计数器只能递减，不能重置。

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);

        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                // 执行任务
                latch.countDown();
            }).start();
        }

        latch.await(); // 等待所有线程完成任务
        System.out.println("所有任务完成");
    }
}

5.2 CyclicBarrier

CyclicBarrier是一个同步辅助类，允许多个线程相互等待，直到所有线程都到达某个屏障点。与CountDownLatch不同，CyclicBarrier的计数器可以重置。

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(3, () -> {
            System.out.println("所有线程到达屏障");
        });

        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                try {
                    // 执行任务
                    barrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

5.3 Semaphore

Semaphore是一个计数信号量，用于控制同时访问某个资源的线程数量。Semaphore可以用于实现资源池、限流等功能。

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3); // 允许3个线程同时访问

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    // 访问资源
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

5.4 Exchanger

Exchanger是一个同步点，用于两个线程之间交换数据。Exchanger适用于两个线程需要相互传递数据的场景。

import java.util.concurrent.Exchanger;

public class ExchangerExample {
    public static void main(String[] args) {
        Exchanger<String> exchanger = new Exchanger<>();

        new Thread(() -> {
            try {
                String data = exchanger.exchange("data1");
                System.out.println("线程1收到数据: " + data);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                String data = exchanger.exchange("data2");
                System.out.println("线程2收到数据: " + data);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

6. 其他工具类

6.1 CompletableFuture

CompletableFuture是Java 8引入的一个类，用于异步编程。CompletableFuture可以组合多个异步任务，并处理它们的完成结果。

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 执行异步任务
            return "result";
        });

        future.thenAccept(result -> {
            System.out.println("任务完成，结果: " + result);
        });
    }
}

6.2 ForkJoinPool

ForkJoinPool是Java 7引入的一个线程池实现，适用于分治算法的场景。ForkJoinPool使用工作窃取算法来提高并行任务的执行效率。

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class ForkJoinPoolExample {
    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();
        int result = pool.invoke(new FibonacciTask(10));
        System.out.println("Fibonacci(10) = " + result);
    }

    static class FibonacciTask extends RecursiveTask<Integer> {
        private final int n;

        FibonacciTask(int n) {
            this.n = n;
        }

        @Override
        protected Integer compute() {
            if (n <= 1) {
                return n;
            }
            FibonacciTask task1 = new FibonacciTask(n - 1);
            task1.fork();
            FibonacciTask task2 = new FibonacciTask(n - 2);
            return task2.compute() + task1.join();
        }
    }
}

7. 总结

JUC包提供了丰富的工具类来简化并发编程的复杂性。通过合理使用这些工具类，开发者可以编写出高效、安全的并发程序。本文介绍了JUC包中的主要工具类及其使用场景，希望对读者有所帮助。