"并发优化就像指挥交响乐团，每个乐手都要协调配合，才能演奏出美妙的音乐！" 🎼🎵
🎯 什么是并发与多线程优化？
想象一下，你是一个超级忙碌的餐厅经理 🍽️。每天都有很多客人来用餐，如果你只用一个服务员，那效率太低了！
并发与多线程优化就像是学会最聪明的员工管理方法，让多个服务员同时工作，提高整体效率！
🏃♂️ 核心思想：用多线程换并行处理，用优化换性能
未优化：单线程处理 → 串行执行 → 效率低下
已优化：多线程处理 → 并行执行 → 效率提升
效率提升：2-8倍！ 🎉
🎨 并发与多线程优化的四种策略
1. 线程管理 - 让线程"工作"更有序 👥
生活比喻： 就像管理员工，从招聘到培训，从分配到监督，每个环节都要精心安排！
@Service
public class ThreadManagementService {
// 线程池优化
public static class OptimizedThreadPool {
private final ThreadPoolExecutor executorService;
private final ScheduledExecutorService scheduledExecutorService;
private final ForkJoinPool forkJoinPool;
public OptimizedThreadPool() {
// 核心线程数 = CPU核心数
int corePoolSize = Runtime.getRuntime().availableProcessors();
// 最大线程数 = CPU核心数 * 2
int maxPoolSize = corePoolSize * 2;
// 线程空闲时间
long keepAliveTime = 60L;
this.executorService = new ThreadPoolExecutor(
corePoolSize,
maxPoolSize,
keepAliveTime,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(1000),
new ThreadFactory() {
private final AtomicInteger threadNumber = new AtomicInteger(1);
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r, "optimized-pool-" + threadNumber.getAndIncrement());
t.setDaemon(true);
t.setPriority(Thread.NORM_PRIORITY);
return t;
}
},
new ThreadPoolExecutor.CallerRunsPolicy()
);
this.scheduledExecutorService = Executors.newScheduledThreadPool(2);
this.forkJoinPool = new ForkJoinPool(corePoolSize);
}
public void execute(Runnable task) {
executorService.execute(task);
}
public Future<?> submit(Runnable task) {
return executorService.submit(task);
}
public <T> Future<T> submit(Callable<T> task) {
return executorService.submit(task);
}
public ScheduledFuture<?> schedule(Runnable task, long delay, TimeUnit unit) {
return scheduledExecutorService.schedule(task, delay, unit);
}
public <T> T invoke(ForkJoinTask<T> task) {
return forkJoinPool.invoke(task);
}
public void shutdown() {
executorService.shutdown();
scheduledExecutorService.shutdown();
forkJoinPool.shutdown();
}
}
// 任务队列选择
public static class TaskQueueSelector {
// 有界队列 - 适合CPU密集型任务
public BlockingQueue<Runnable> createBoundedQueue(int capacity) {
return new ArrayBlockingQueue<>(capacity);
}
// 无界队列 - 适合IO密集型任务
public BlockingQueue<Runnable> createUnboundedQueue() {
return new LinkedBlockingQueue<>();
}
// 同步队列 - 适合需要立即执行的任务
public BlockingQueue<Runnable> createSynchronousQueue() {
return new SynchronousQueue<>();
}
// 优先级队列 - 适合有优先级要求的任务
public BlockingQueue<Runnable> createPriorityQueue() {
return new PriorityBlockingQueue<>();
}
}
// 拒绝策略设计
public static class RejectionPolicyDesigner {
// 自定义拒绝策略
public static class CustomRejectionPolicy implements RejectedExecutionHandler {
private final AtomicInteger rejectedCount = new AtomicInteger(0);
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
rejectedCount.incrementAndGet();
log.warn("任务被拒绝，当前拒绝次数: {}", rejectedCount.get());
// 尝试重新提交
if (!executor.isShutdown()) {
try {
executor.getQueue().offer(r, 100, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
log.error("重新提交任务失败", e);
}
}
}
public int getRejectedCount() {
return rejectedCount.get();
}
}
// 监控拒绝策略
public static class MonitoringRejectionPolicy implements RejectedExecutionHandler {
private final MeterRegistry meterRegistry;
private final Counter rejectionCounter;
public MonitoringRejectionPolicy(MeterRegistry meterRegistry) {
this.meterRegistry = meterRegistry;
this.rejectionCounter = Counter.builder("threadpool.rejection.count")
.register(meterRegistry);
}
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
rejectionCounter.increment();
log.warn("任务被拒绝，线程池状态: 活跃线程={}, 队列大小={}",
executor.getActiveCount(), executor.getQueue().size());
}
}
}
// 监控与调优
public static class ThreadPoolMonitor {
private final ThreadPoolExecutor executor;
private final ScheduledExecutorService monitorExecutor;
public ThreadPoolMonitor(ThreadPoolExecutor executor) {
this.executor = executor;
this.monitorExecutor = Executors.newSingleThreadScheduledExecutor();
// 定期监控线程池状态
monitorExecutor.scheduleAtFixedRate(this::monitorThreadPool, 0, 5, TimeUnit.SECONDS);
}
private void monitorThreadPool() {
log.info("线程池状态: 核心线程数={}, 活跃线程数={}, 最大线程数={}, 队列大小={}",
executor.getCorePoolSize(),
executor.getActiveCount(),
executor.getMaximumPoolSize(),
executor.getQueue().size());
// 动态调整线程池大小
adjustThreadPoolSize();
}
private void adjustThreadPoolSize() {
int activeCount = executor.getActiveCount();
int corePoolSize = executor.getCorePoolSize();
int maxPoolSize = executor.getMaximumPoolSize();
// 如果活跃线程数接近最大线程数，增加核心线程数
if (activeCount > maxPoolSize * 0.8) {
int newCorePoolSize = Math.min(corePoolSize + 2, maxPoolSize);
executor.setCorePoolSize(newCorePoolSize);
log.info("增加核心线程数到: {}", newCorePoolSize);
}
// 如果活跃线程数很少，减少核心线程数
else if (activeCount < corePoolSize * 0.3) {
int newCorePoolSize = Math.max(corePoolSize - 1, 1);
executor.setCorePoolSize(newCorePoolSize);
log.info("减少核心线程数到: {}", newCorePoolSize);
}
}
public void shutdown() {
monitorExecutor.shutdown();
}
}
}
2. 线程同步优化 - 让线程"协作"更和谐 🤝
生活比喻： 就像交通信号灯，让车辆有序通过，避免拥堵和事故！
@Service
public class ThreadSynchronizationOptimizationService {
// 锁粒度控制
public static class LockGranularityController {
// 细粒度锁 - 提高并发性
private final Map<String, Object> locks = new ConcurrentHashMap<>();
private final Map<String, String> data = new ConcurrentHashMap<>();
public void updateData(String key, String value) {
Object lock = locks.computeIfAbsent(key, k -> new Object());
synchronized (lock) {
data.put(key, value);
}
}
public String getData(String key) {
Object lock = locks.get(key);
if (lock != null) {
synchronized (lock) {
return data.get(key);
}
}
return null;
}
// 粗粒度锁 - 简单但并发性低
private final Object globalLock = new Object();
private final Map<String, String> globalData = new HashMap<>();
public void updateGlobalData(String key, String value) {
synchronized (globalLock) {
globalData.put(key, value);
}
}
public String getGlobalData(String key) {
synchronized (globalLock) {
return globalData.get(key);
}
}
}
// 读写锁使用
public static class ReadWriteLockOptimizer {
private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
private final Map<String, String> data = new HashMap<>();
public String read(String key) {
lock.readLock().lock();
try {
return data.get(key);
} finally {
lock.readLock().unlock();
}
}
public void write(String key, String value) {
lock.writeLock().lock();
try {
data.put(key, value);
} finally {
lock.writeLock().unlock();
}
}
// 读写锁升级
public String readAndUpdate(String key, String newValue) {
lock.readLock().lock();
try {
String currentValue = data.get(key);
if (currentValue != null) {
// 升级为写锁
lock.readLock().unlock();
lock.writeLock().lock();
try {
// 双重检查
currentValue = data.get(key);
if (currentValue != null) {
data.put(key, newValue);
}
return currentValue;
} finally {
lock.readLock().lock(); // 降级为读锁
lock.writeLock().unlock();
}
}
return null;
} finally {
lock.readLock().unlock();
}
}
}
// 无锁编程
public static class LockFreeProgramming {
// CAS操作优化
private final AtomicInteger counter = new AtomicInteger(0);
private final AtomicReference<String> value = new AtomicReference<>();
public int increment() {
return counter.incrementAndGet();
}
public int decrement() {
return counter.decrementAndGet();
}
public boolean compareAndSet(String expected, String update) {
return value.compareAndSet(expected, update);
}
// 无锁栈
public static class LockFreeStack<T> {
private final AtomicReference<Node<T>> head = new AtomicReference<>();
public void push(T value) {
Node<T> newNode = new Node<>(value);
Node<T> currentHead;
do {
currentHead = head.get();
newNode.next = currentHead;
} while (!head.compareAndSet(currentHead, newNode));
}
public T pop() {
Node<T> currentHead;
Node<T> newHead;
do {
currentHead = head.get();
if (currentHead == null) {
return null;
}
newHead = currentHead.next;
} while (!head.compareAndSet(currentHead, newHead));
return currentHead.value;
}
private static class Node<T> {
final T value;
Node<T> next;
Node(T value) {
this.value = value;
}
}
}
// 无锁队列
public static class LockFreeQueue<T> {
private final AtomicReference<Node<T>> head = new AtomicReference<>();
private final AtomicReference<Node<T>> tail = new AtomicReference<>();
public LockFreeQueue() {
Node<T> dummy = new Node<>(null);
head.set(dummy);
tail.set(dummy);
}
public void enqueue(T value) {
Node<T> newNode = new Node<>(value);
Node<T> currentTail;
Node<T> currentTailNext;
while (true) {
currentTail = tail.get();
currentTailNext = currentTail.next;
if (currentTail == tail.get()) {
if (currentTailNext == null) {
if (currentTail.next.compareAndSet(null, newNode)) {
break;
}
} else {
tail.compareAndSet(currentTail, currentTailNext);
}
}
}
tail.compareAndSet(currentTail, newNode);
}
public T dequeue() {
Node<T> currentHead;
Node<T> currentTail;
Node<T> currentHeadNext;
T value;
while (true) {
currentHead = head.get();
currentTail = tail.get();
currentHeadNext = currentHead.next;
if (currentHead == head.get()) {
if (currentHead == currentTail) {
if (currentHeadNext == null) {
return null;
}
tail.compareAndSet(currentTail, currentHeadNext);
} else {
if (currentHeadNext == null) {
continue;
}
value = currentHeadNext.value;
if (head.compareAndSet(currentHead, currentHeadNext)) {
break;
}
}
}
}
return value;
}
private static class Node<T> {
final T value;
final AtomicReference<Node<T>> next = new AtomicReference<>();
Node(T value) {
this.value = value;
}
}
}
}
// CAS操作优化
public static class CASOperationOptimizer {
// 原子操作优化
private final AtomicLong counter = new AtomicLong(0);
private final AtomicReferenceArray<String> array = new AtomicReferenceArray<>(100);
public long incrementCounter() {
return counter.incrementAndGet();
}
public long decrementCounter() {
return counter.decrementAndGet();
}
public long addToCounter(long delta) {
return counter.addAndGet(delta);
}
public boolean setArrayElement(int index, String expected, String update) {
return array.compareAndSet(index, expected, update);
}
// 原子字段更新
public static class AtomicFieldUpdater {
private volatile int value;
private static final AtomicIntegerFieldUpdater<AtomicFieldUpdater> updater =
AtomicIntegerFieldUpdater.newUpdater(AtomicFieldUpdater.class, "value");
public int getValue() {
return value;
}
public boolean compareAndSet(int expected, int update) {
return updater.compareAndSet(this, expected, update);
}
public int incrementAndGet() {
return updater.incrementAndGet(this);
}
}
}
}
3. 线程通信优化 - 让线程"交流"更顺畅 💬
生活比喻： 就像团队沟通，用对了沟通方式，信息传递更高效！
@Service
public class ThreadCommunicationOptimizationService {
// 消息队列
public static class MessageQueueOptimizer {
private final BlockingQueue<Message> messageQueue;
private final ExecutorService consumerExecutor;
private final AtomicBoolean running = new AtomicBoolean(true);
public MessageQueueOptimizer(int queueSize, int consumerThreads) {
this.messageQueue = new ArrayBlockingQueue<>(queueSize);
this.consumerExecutor = Executors.newFixedThreadPool(consumerThreads);
// 启动消费者线程
for (int i = 0; i < consumerThreads; i++) {
consumerExecutor.submit(new MessageConsumer());
}
}
public boolean sendMessage(Message message) {
try {
return messageQueue.offer(message, 100, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return false;
}
}
private class MessageConsumer implements Runnable {
@Override
public void run() {
while (running.get()) {
try {
Message message = messageQueue.poll(1, TimeUnit.SECONDS);
if (message != null) {
processMessage(message);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
}
private void processMessage(Message message) {
// 处理消息
log.info("处理消息: {}", message.getContent());
}
}
public void shutdown() {
running.set(false);
consumerExecutor.shutdown();
}
private static class Message {
private final String content;
private final long timestamp;
Message(String content) {
this.content = content;
this.timestamp = System.currentTimeMillis();
}
String getContent() {
return content;
}
long getTimestamp() {
return timestamp;
}
}
}
// 管道通信
public static class PipeCommunicationOptimizer {
private final PipedInputStream inputStream;
private final PipedOutputStream outputStream;
private final ExecutorService executor;
public PipeCommunicationOptimizer() throws IOException {
this.inputStream = new PipedInputStream();
this.outputStream = new PipedOutputStream(inputStream);
this.executor = Executors.newFixedThreadPool(2);
}
public void startCommunication() {
// 启动生产者
executor.submit(new Producer());
// 启动消费者
executor.submit(new Consumer());
}
private class Producer implements Runnable {
@Override
public void run() {
try {
for (int i = 0; i < 10; i++) {
String data = "Data " + i;
outputStream.write(data.getBytes());
outputStream.flush();
Thread.sleep(100);
}
outputStream.close();
} catch (IOException | InterruptedException e) {
log.error("生产者异常", e);
}
}
}
private class Consumer implements Runnable {
@Override
public void run() {
try {
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = inputStream.read(buffer)) != -1) {
String data = new String(buffer, 0, bytesRead);
log.info("接收到数据: {}", data);
}
inputStream.close();
} catch (IOException e) {
log.error("消费者异常", e);
}
}
}
public void shutdown() {
executor.shutdown();
}
}
// 信号量使用
public static class SemaphoreOptimizer {
private final Semaphore semaphore;
private final AtomicInteger activeCount = new AtomicInteger(0);
public SemaphoreOptimizer(int permits) {
this.semaphore = new Semaphore(permits);
}
public void executeTask(Runnable task) {
try {
semaphore.acquire();
activeCount.incrementAndGet();
try {
task.run();
} finally {
activeCount.decrementAndGet();
semaphore.release();
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
log.error("获取信号量失败", e);
}
}
public int getActiveCount() {
return activeCount.get();
}
public int getAvailablePermits() {
return semaphore.availablePermits();
}
}
// 条件变量
public static class ConditionVariableOptimizer {
private final ReentrantLock lock = new ReentrantLock();
private final Condition condition = lock.newCondition();
private final AtomicBoolean ready = new AtomicBoolean(false);
public void waitForCondition() {
lock.lock();
try {
while (!ready.get()) {
condition.await();
}
log.info("条件满足，继续执行");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
log.error("等待条件失败", e);
} finally {
lock.unlock();
}
}
public void signalCondition() {
lock.lock();
try {
ready.set(true);
condition.signalAll();
log.info("条件已满足，通知等待线程");
} finally {
lock.unlock();
}
}
public void resetCondition() {
lock.lock();
try {
ready.set(false);
} finally {
lock.unlock();
}
}
}
}
4. 并发数据结构 - 让数据"并发"更安全 🔒
生活比喻： 就像银行金库，多个人同时存取，但数据绝对安全！
@Service
public class ConcurrentDataStructureService {
// 无锁数据结构
public static class LockFreeDataStructures {
// Lock-Free算法
public static class LockFreeAlgorithm {
private final AtomicReference<Node> head = new AtomicReference<>();
public void add(int value) {
Node newNode = new Node(value);
Node currentHead;
do {
currentHead = head.get();
newNode.next = currentHead;
} while (!head.compareAndSet(currentHead, newNode));
}
public boolean contains(int value) {
Node current = head.get();
while (current != null) {
if (current.value == value) {
return true;
}
current = current.next;
}
return false;
}
private static class Node {
final int value;
volatile Node next;
Node(int value) {
this.value = value;
}
}
}
// Wait-Free算法
public static class WaitFreeAlgorithm {
private final AtomicInteger counter = new AtomicInteger(0);
private final AtomicReferenceArray<Integer> array = new AtomicReferenceArray<>(1000);
public void increment() {
int index = counter.getAndIncrement() % array.length();
array.set(index, counter.get());
}
public int getValue(int index) {
return array.get(index);
}
}
// 原子操作
public static class AtomicOperations {
private final AtomicLong counter = new AtomicLong(0);
private final AtomicReference<String> value = new AtomicReference<>();
public long increment() {
return counter.incrementAndGet();
}
public long decrement() {
return counter.decrementAndGet();
}
public boolean compareAndSet(String expected, String update) {
return value.compareAndSet(expected, update);
}
public String getValue() {
return value.get();
}
}
// 内存屏障
public static class MemoryBarrier {
private volatile int value;
private volatile boolean ready;
public void setValue(int value) {
this.value = value;
// 写屏障，确保value的写入在ready的写入之前完成
this.ready = true;
}
public int getValue() {
if (ready) {
// 读屏障，确保ready的读取在value的读取之前完成
return value;
}
return 0;
}
}
}
// 并发容器
public static class ConcurrentContainers {
// ConcurrentHashMap优化
public static class ConcurrentHashMapOptimizer {
private final ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
public void put(String key, String value) {
map.put(key, value);
}
public String get(String key) {
return map.get(key);
}
public String computeIfAbsent(String key, Function<String, String> mappingFunction) {
return map.computeIfAbsent(key, mappingFunction);
}
public void forEach(BiConsumer<String, String> action) {
map.forEach(action);
}
// 批量操作
public void putAll(Map<String, String> otherMap) {
otherMap.forEach(map::put);
}
// 原子操作
public String putIfAbsent(String key, String value) {
return map.putIfAbsent(key, value);
}
public boolean remove(String key, String value) {
return map.remove(key, value);
}
public String replace(String key, String value) {
return map.replace(key, value);
}
}
// ConcurrentLinkedQueue优化
public static class ConcurrentLinkedQueueOptimizer {
private final ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();
public boolean offer(String item) {
return queue.offer(item);
}
public String poll() {
return queue.poll();
}
public String peek() {
return queue.peek();
}
public boolean isEmpty() {
return queue.isEmpty();
}
public int size() {
return queue.size();
}
// 批量操作
public void addAll(Collection<String> items) {
queue.addAll(items);
}
public List<String> drainTo(int maxElements) {
List<String> result = new ArrayList<>();
String item;
int count = 0;
while (count < maxElements && (item = queue.poll()) != null) {
result.add(item);
count++;
}
return result;
}
}
// CopyOnWriteArrayList优化
public static class CopyOnWriteArrayListOptimizer {
private final CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
public void add(String item) {
list.add(item);
}
public String get(int index) {
return list.get(index);
}
public boolean remove(String item) {
return list.remove(item);
}
public int size() {
return list.size();
}
public void forEach(Consumer<String> action) {
list.forEach(action);
}
// 批量操作
public void addAll(Collection<String> items) {
list.addAll(items);
}
public List<String> subList(int fromIndex, int toIndex) {
return list.subList(fromIndex, toIndex);
}
}
// BlockingQueue优化
public static class BlockingQueueOptimizer {
private final BlockingQueue<String> queue = new ArrayBlockingQueue<>(1000);
public boolean offer(String item) {
return queue.offer(item);
}
public boolean offer(String item, long timeout, TimeUnit unit) throws InterruptedException {
return queue.offer(item, timeout, unit);
}
public String poll() {
return queue.poll();
}
public String poll(long timeout, TimeUnit unit) throws InterruptedException {
return queue.poll(timeout, unit);
}
public String take() throws InterruptedException {
return queue.take();
}
public void put(String item) throws InterruptedException {
queue.put(item);
}
public int remainingCapacity() {
return queue.remainingCapacity();
}
}
}
// 并发模式
public static class ConcurrentPatterns {
// Producer-Consumer模式
public static class ProducerConsumerPattern {
private final BlockingQueue<String> queue = new ArrayBlockingQueue<>(100);
private final ExecutorService executor = Executors.newFixedThreadPool(4);
private final AtomicBoolean running = new AtomicBoolean(true);
public void start() {
// 启动生产者
executor.submit(new Producer());
executor.submit(new Producer());
// 启动消费者
executor.submit(new Consumer());
executor.submit(new Consumer());
}
private class Producer implements Runnable {
@Override
public void run() {
int count = 0;
while (running.get()) {
try {
String item = "Item-" + count++;
queue.put(item);
log.info("生产者生产: {}", item);
Thread.sleep(100);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
}
}
private class Consumer implements Runnable {
@Override
public void run() {
while (running.get()) {
try {
String item = queue.take();
log.info("消费者消费: {}", item);
Thread.sleep(150);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
}
}
public void shutdown() {
running.set(false);
executor.shutdown();
}
}
// Master-Worker模式
public static class MasterWorkerPattern {
private final ExecutorService masterExecutor = Executors.newSingleThreadExecutor();
private final ExecutorService workerExecutor = Executors.newFixedThreadPool(4);
private final BlockingQueue<Task> taskQueue = new LinkedBlockingQueue<>();
private final BlockingQueue<Result> resultQueue = new LinkedBlockingQueue<>();
private final AtomicBoolean running = new AtomicBoolean(true);
public void start() {
// 启动Master
masterExecutor.submit(new Master());
// 启动Workers
for (int i = 0; i < 4; i++) {
workerExecutor.submit(new Worker(i));
}
}
private class Master implements Runnable {
@Override
public void run() {
int taskId = 0;
while (running.get()) {
try {
Task task = new Task(taskId++, "Task-" + taskId);
taskQueue.put(task);
log.info("Master分配任务: {}", task);
Thread.sleep(200);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
}
}
private class Worker implements Runnable {
private final int workerId;
Worker(int workerId) {
this.workerId = workerId;
}
@Override
public void run() {
while (running.get()) {
try {
Task task = taskQueue.poll(1, TimeUnit.SECONDS);
if (task != null) {
Result result = processTask(task);
resultQueue.put(result);
log.info("Worker-{}处理任务: {}, 结果: {}", workerId, task, result);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
}
private Result processTask(Task task) {
// 模拟任务处理
try {
Thread.sleep(100);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
return new Result(task.getId(), "Result-" + task.getId());
}
}
public void shutdown() {
running.set(false);
masterExecutor.shutdown();
workerExecutor.shutdown();
}
private static class Task {
private final int id;
private final String name;
Task(int id, String name) {
this.id = id;
this.name = name;
}
int getId() { return id; }
String getName() { return name; }
@Override
public String toString() {
return "Task{id=" + id + ", name='" + name + "'}";
}
}
private static class Result {
private final int taskId;
private final String result;
Result(int taskId, String result) {
this.taskId = taskId;
this.result = result;
}
int getTaskId() { return taskId; }
String getResult() { return result; }
@Override
public String toString() {
return "Result{taskId=" + taskId + ", result='" + result + "'}";
}
}
}
// Pipeline模式
public static class PipelinePattern {
private final ExecutorService executor = Executors.newFixedThreadPool(3);
private final BlockingQueue<String> stage1Queue = new LinkedBlockingQueue<>();
private final BlockingQueue<String> stage2Queue = new LinkedBlockingQueue<>();
private final BlockingQueue<String> stage3Queue = new LinkedBlockingQueue<>();
private final AtomicBoolean running = new AtomicBoolean(true);
public void start() {
// 启动各个阶段的处理器
executor.submit(new Stage1Processor());
executor.submit(new Stage2Processor());
executor.submit(new Stage3Processor());
}
private class Stage1Processor implements Runnable {
@Override
public void run() {
int count = 0;
while (running.get()) {
try {
String data = "Data-" + count++;
stage1Queue.put(data);
log.info("Stage1处理: {}", data);
Thread.sleep(100);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
}
}
private class Stage2Processor implements Runnable {
@Override
public void run() {
while (running.get()) {
try {
String data = stage1Queue.poll(1, TimeUnit.SECONDS);
if (data != null) {
String processedData = data + "-Processed";
stage2Queue.put(processedData);
log.info("Stage2处理: {} -> {}", data, processedData);
Thread.sleep(150);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
}
}
private class Stage3Processor implements Runnable {
@Override
public void run() {
while (running.get()) {
try {
String data = stage2Queue.poll(1, TimeUnit.SECONDS);
if (data != null) {
String finalData = data + "-Final";
stage3Queue.put(finalData);
log.info("Stage3处理: {} -> {}", data, finalData);
Thread.sleep(200);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
}
}
public void shutdown() {
running.set(false);
executor.shutdown();
}
}
// Actor模型
public static class ActorModel {
private final ExecutorService executor = Executors.newCachedThreadPool();
private final Map<String, Actor> actors = new ConcurrentHashMap<>();
public void createActor(String name, Actor actor) {
actors.put(name, actor);
executor.submit(actor);
}
public void sendMessage(String actorName, Object message) {
Actor actor = actors.get(actorName);
if (actor != null) {
actor.receive(message);
}
}
public void shutdown() {
actors.values().forEach(Actor::stop);
executor.shutdown();
}
public static abstract class Actor implements Runnable {
private final BlockingQueue<Object> mailbox = new LinkedBlockingQueue<>();
private volatile boolean running = true;
@Override
public void run() {
while (running) {
try {
Object message = mailbox.poll(1, TimeUnit.SECONDS);
if (message != null) {
handleMessage(message);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
}
public void receive(Object message) {
mailbox.offer(message);
}
public void stop() {
running = false;
}
protected abstract void handleMessage(Object message);
}
}
}
}
🎯 并发与多线程优化的实际应用
1. 高并发Web服务 🚀
@Service
public class HighConcurrencyWebService {
// 异步处理请求
@Async
public CompletableFuture<String> processRequestAsync(String request) {
return CompletableFuture.supplyAsync(() -> {
// 模拟处理时间
try {
Thread.sleep(100);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
return "Processed: " + request;
});
}
// 批量处理请求
public List<String> processBatchRequests(List<String> requests) {
return requests.parallelStream()
.map(this::processRequest)
.collect(Collectors.toList());
}
private String processRequest(String request) {
// 处理单个请求
return "Processed: " + request;
}
// 限流处理
public static class RateLimiter {
private final Semaphore semaphore;
private final ScheduledExecutorService scheduler;
public RateLimiter(int permits) {
this.semaphore = new Semaphore(permits);
this.scheduler = Executors.newScheduledThreadPool(1);
// 每秒释放一个许可
scheduler.scheduleAtFixedRate(() -> {
if (semaphore.availablePermits() < permits) {
semaphore.release();
}
}, 0, 1, TimeUnit.SECONDS);
}
public boolean tryAcquire() {
return semaphore.tryAcquire();
}
public void acquire() throws InterruptedException {
semaphore.acquire();
}
public void shutdown() {
scheduler.shutdown();
}
}
}
2. 数据处理管道 📊
@Service
public class DataProcessingPipeline {
// 并行数据处理
public void processDataInParallel(List<DataRecord> data) {
data.parallelStream()
.filter(this::isValidRecord)
.map(this::transformRecord)
.forEach(this::processRecord);
}
private boolean isValidRecord(DataRecord record) {
return record != null && record.isValid();
}
private DataRecord transformRecord(DataRecord record) {
// 转换记录
return record;
}
private void processRecord(DataRecord record) {
// 处理记录
}
// 分阶段处理
public void processDataInStages(List<DataRecord> data) {
// 第一阶段：验证
List<DataRecord> validatedData = data.parallelStream()
.filter(this::isValidRecord)
.collect(Collectors.toList());
// 第二阶段：转换
List<DataRecord> transformedData = validatedData.parallelStream()
.map(this::transformRecord)
.collect(Collectors.toList());
// 第三阶段：处理
transformedData.parallelStream()
.forEach(this::processRecord);
}
private static class DataRecord {
private final String data;
private final long timestamp;
DataRecord(String data, long timestamp) {
this.data = data;
this.timestamp = timestamp;
}
boolean isValid() {
return data != null && !data.isEmpty();
}
}
}
🛡️ 并发与多线程优化的注意事项
1. 死锁避免 🔒
@Service
public class DeadlockPreventionService {
// 锁顺序一致
public static class LockOrderConsistency {
private final Object lock1 = new Object();
private final Object lock2 = new Object();
public void method1() {
synchronized (lock1) {
synchronized (lock2) {
// 处理逻辑
}
}
}
public void method2() {
synchronized (lock1) { // 保持相同的锁顺序
synchronized (lock2) {
// 处理逻辑
}
}
}
}
// 超时锁
public static class TimeoutLock {
private final ReentrantLock lock = new ReentrantLock();
public boolean tryLockWithTimeout(long timeout, TimeUnit unit) {
try {
return lock.tryLock(timeout, unit);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return false;
}
}
public void unlock() {
lock.unlock();
}
}
// 死锁检测
public static class DeadlockDetector {
private final ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
public void detectDeadlock() {
long[] deadlockedThreads = threadBean.findDeadlockedThreads();
if (deadlockedThreads != null) {
log.error("检测到死锁，涉及线程: {}", Arrays.toString(deadlockedThreads));
ThreadInfo[] threadInfos = threadBean.getThreadInfo(deadlockedThreads);
for (ThreadInfo threadInfo : threadInfos) {
log.error("死锁线程信息: {}", threadInfo);
}
}
}
}
}
2. 性能监控 📊
@Service
public class ConcurrencyPerformanceMonitor {
public void monitorThreadPool(ThreadPoolExecutor executor) {
log.info("线程池状态: 核心线程数={}, 活跃线程数={}, 最大线程数={}, 队列大小={}",
executor.getCorePoolSize(),
executor.getActiveCount(),
executor.getMaximumPoolSize(),
executor.getQueue().size());
// 监控任务完成情况
long completedTaskCount = executor.getCompletedTaskCount();
long taskCount = executor.getTaskCount();
log.info("任务完成情况: 已完成={}, 总任务数={}", completedTaskCount, taskCount);
}
public void monitorThreadStatus() {
ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
// 获取所有线程信息
ThreadInfo[] threadInfos = threadBean.getThreadInfo(threadBean.getAllThreadIds());
for (ThreadInfo threadInfo : threadInfos) {
if (threadInfo != null) {
log.info("线程状态: 名称={}, 状态={}, 阻塞时间={}ms",
threadInfo.getThreadName(),
threadInfo.getThreadState(),
threadInfo.getBlockedTime());
}
}
}
}
📊 并发与多线程优化监控：让性能可视化
@Component
public class ConcurrencyOptimizationMonitor {
private final MeterRegistry meterRegistry;
private final Timer taskTimer;
private final Counter taskCounter;
private final Gauge threadPoolSize;
public ConcurrencyOptimizationMonitor(MeterRegistry meterRegistry) {
this.meterRegistry = meterRegistry;
this.taskTimer = Timer.builder("concurrency.task.execution.time")
.register(meterRegistry);
this.taskCounter = Counter.builder("concurrency.task.count")
.register(meterRegistry);
this.threadPoolSize = Gauge.builder("concurrency.threadpool.size")
.register(meterRegistry);
}
public void recordTaskExecution(Duration duration, String taskType) {
taskTimer.record(duration);
taskCounter.increment(Tags.of("task", taskType));
}
public void recordThreadPoolSize(int size) {
threadPoolSize.set(size);
}
}
🎉 总结：并发与多线程优化让程序"多手"协作更高效
并发与多线程优化就像生活中的各种"协作"技巧：
- 线程管理 = 管理员工团队 👥
- 线程同步优化 = 协调交通信号灯 🤝
- 线程通信优化 = 高效团队沟通 💬
- 并发数据结构 = 安全的银行金库 🔒
通过合理使用并发与多线程优化，我们可以：
- 🚀 大幅提升程序性能
- ⚡ 改善系统响应
- 🎯 提高资源利用率
- 💪 增强系统稳定性
记住：并发优化不是万能的，但它是性能提升的利器！ 合理使用并发与多线程优化，让你的Java应用运行如交响乐团般协调！ ✨
"并发优化就像魔法，让程序多手协作，让性能更卓越！" 🪄🧵
