Java 并发工具类

Java 提供了丰富的并发工具类，用于简化多线程编程并提高程序的性能和可靠性。

锁机制

ReentrantLock 可重入锁

特点：

• 可重入：通一个线程可以多次获取同一把锁。
• 支持公平锁和非公平锁（默认是非公平锁）。
• 提供了比 synchronized 更灵活的锁操作，如尝试获取锁、超时获取锁等。

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

public class ReentrantLockExample {
    private final Lock lock = new ReentrantLock();
    private int count = 0;
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

ReadWriteLock 读写锁

特点：

• 读写锁分为读锁和写锁。
• 读锁是共享锁，允许多个线程同时读取。
• 写锁是独占锁，只允许一个线程写入。

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

public class ReadWriteLockExample {
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
    private int value = 0;
    public int getValue() {
        rwLock.readLock().lock();
        try {
            return value;
        } finally {
            rwLock.readLock().unlock();
        }
    }
    public void setValue(int value) {
        rwLock.writeLock().lock();
        try {
            this.value = value;
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

StampedLock 改进的读写锁

特点：

• 提供了更高效的读写锁实现。
• 支持乐观读锁，减少锁竞争。

import java.util.concurrent.locks.StampedLock;

public class StampedLockExample {
    private final StampedLock stampedLock = new StampedLock();
    private int value = 0;
    public int getValue() {
        long stamp = stampedLock.tryOptimisticRead();
        int currentValue = value;
        if (!stampedLock.validate(stamp)) {
            stamp = stampedLock.readLock();
            try {
                currentValue = value;
            } finally {
                stampedLock.unlockRead(stamp);
            }
        }
        return currentValue;
    }
    public void setValue(int value) {
        long stamp = stampedLock.writeLock();
        try {
            this.value = value;
        } finally {
            stampedLock.unlockWrite(stamp);
        }
    }
}

线程池

Executor 框架

Executor 是线程池的顶层接口，提供了任务提交与执行分离的机制。

主要实现类：ThreadPoolExecutor、ScheduledThreadPoolExecutor。

ThreadPoolExecutor 的使用与配置

核心参数：

1. 核心线程数（corePoolSize）：线程池中保持的最小线程数。
2. 最大线程数（maximumPoolSize）：线程池中允许的最大线程数。
3. 队列类型（workQueue）：用于存放等待执行的任务的阻塞队列。
4. 拒绝策略（rejectedExecutionHandler）：当任务无法被执行时的处理策略。

import java.util.concurrent.*;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2, // 核心线程数
            4, // 最大线程数
            60, // 空闲线程存活时间
            TimeUnit.SECONDS, // 时间单位
            new LinkedBlockingQueue<>(10), // 任务队列
            new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
        );
        executor.execute(() -> System.out.println("Task executed"));
        executor.shutdown();
    }
}

常见的线程池类型

1. FixedThreadPool：固定大小的线程池，适用于执行长期的任务。

   ExecutorService executor = Executors.newFixedThreadPool(4);

2. CachedThreadPool：可缓存的线程池，线程数根据需要动态调整。

   ExecutorService executor = Executors.newCachedThreadPool();

3. ScheduledThreadPool：支持定时任务和周期性任务的线程池。

   ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
   executor.schedule(() -> System.out.println("Task executed"), 5, TimeUnit.SECONDS);

4. SingleThreadExecutor：单线程的线程池，保证任务按顺序执行。

   ExecutorService executor = Executors.newSingleThreadExecutor();

并发集合

ConcurrentHashMap

特点：

• 线程安全的哈希表，支持高并发读写。
• 使用分段锁（JDK 7）或 CAS 操作（JDK 8+）实现线程安全。

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        map.put("key", 1);
        System.out.println(map.get("key"));
    }
}

CopyOnWriteArrayList

特点：

• 线程安全的动态数组，使用于读多写少的场景。
• 写操作时复制整个数组，保证读操作不受影响。

import java.util.concurrent.CopyOnWriteArrayList;

public class CopyOnWriteArrayListExample {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        list.add("item");
        System.out.println(list.get(0));
    }
}

BlockingQueue 及其实现类

特点：

• 阻塞队列，支持线程安全的入队和出队操作。
• 常见实现类：
  1. ArrayBlockingQueue：基于数组的有界阻塞队列。
  2. LinkedBlockingQueue：基于链表的可选有界阻塞队列。
  3. PriorityBlockingQueue：基于优先级排序的无界阻塞队列。

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ArrayBlockingQueue;

public class BlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);
        queue.put("item");
        System.out.println(queue.take());
    }
}

同步工具类

CountDownLatch

特点：

• 用于等待多个线程完成任务。
• 初始化时指定计数，调用 await() 方法等待计数归零。

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(() -> {
                System.out.println("Task completed");
                latch.countDown();
            }).start();
        }
        latch.await();
        System.out.println("All tasks completed");
    }
}

CyclicBarrier

特点：

• 用于让多个线程相互等待，达到屏障点后继续执行。
• 可以重复使用。

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println("All threads reached barrier"));
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                try {
                    System.out.println("Thread waiting");
                    barrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Semaphore

特点：

• 用于控制同时访问资源的线程数。
• 通过 acquire() 和 release() 方法获取和释放许可。

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(2);
        for (int i = 0; i < 4; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println("Thread acquired permit");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }).start();
        }
    }
}

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("Data from Thread 1");
                System.out.println("Thread 1 received: " + data);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(() -> {
            try {
                String data = exchanger.exchange("Data from Thread 2");
                System.out.println("Thread 2 received: " + data);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

总结

• 锁机制（如 ReentrantLock、ReadWriteLock、StampedLock）提供了灵活的线程同步方式。
• 线程池（如 ThreadPoolExecutor）可以高效管理线程资源。
• 并发集合（如 ConcurrentHashMap、CopyOnWriteArrayList）提供了线程安全的数据结构。
• 同步工具类（如 CountDownLatch、CyclicBarrier、Semaphore、Exchanger）用于协调多线程的执行。