当前位置： 首页 > news >正文

JUC之并发编程总结

news 2025/8/27 10:50:18

文章目录

  • 一、Java并发编程体系总览
    • 1.1 基础机制
    • 1.2 并发工具
      • 1.2.1 线程池框架
      • 1.2.2 Lock框架
      • 1.2.3 原子类
      • 1.2.4 并发工具类
    • 1.3 并发集合
    • 1.4 高级特性
  • 二、基础线程机制
    • 2.1 线程创建方式
      • 2.1.1 方式一：继承 Thread 类
      • 2.1.2 方式二: 实现Runnable
      • 2.1.3 实现三: 实现 Callable 接口 + Future
    • 2.2 创建线程方式对比分析
  • 三、线程同步机制
    • 3.1 synchronized 关键字
    • 3.2 Lock框架
    • 3.3 volatile关键字
    • 3.4 同步机制对比分析
      • 3.4 同步机制对比分析
  • 四、线程池框架
    • 4.1 Executor框架
    • 4.2 Fork/Join框架
  • 五、并发集合与工具类
    • 5.1 并发集合框架
    • 5.2 并发工具类
  • 六、Java 并发编程最佳实践总结
    • 6.1 方案选择指南
    • 6.2 实践经验总结
    • 6.3 常见陷阱与避免

一、Java并发编程体系总览

1.1 基础机制

在这里插入图片描述

1.2 并发工具

1.2.1 线程池框架

在这里插入图片描述

1.2.2 Lock框架

在这里插入图片描述

1.2.3 原子类

在这里插入图片描述

1.2.4 并发工具类

在这里插入图片描述

1.3 并发集合

在这里插入图片描述

1.4 高级特性

在这里插入图片描述

Java 并发编程体系
基础机制
并发工具
并发集合
高级特性
线程创建与管理
同步机制
线程池框架
Lock框架
原子类
并发工具类
并发集合
阻塞队列
Fork/Join框架
异步编程
虚拟线程
继承Thread
实现Runnable
实现Callable
synchronized
volatile
原子变量
线程池
定时任务
ReentrantLock
ReadWriteLock
StampedLock
AtomicInteger
AtomicReference
LongAdder
CountDownLatch
CyclicBarrier
Semaphore
Exchanger
ConcurrentHashMap
CopyOnWriteArrayList
ConcurrentSkipListMap
ArrayBlockingQueue
LinkedBlockingQueue
PriorityBlockingQueue

二、基础线程机制

2.1 线程创建方式

2.1.1 方式一：继承 Thread 类

/*** 继承Thread类方式创建线程* 优点：编码简单，直接使用this获取当前线程* 缺点：Java单继承限制，不利于扩展*/
public class CustomThread extends Thread {private final String taskName;public CustomThread(String taskName) {super("CustomThread-" + taskName); // 设置线程名称this.taskName = taskName;}@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + " 开始执行任务: " + taskName);try {// 模拟任务执行Thread.sleep(1000);System.out.println(Thread.currentThread().getName() + " 完成任务: " + taskName);} catch (InterruptedException e) {System.out.println(Thread.currentThread().getName() + " 被中断");Thread.currentThread().interrupt();}}public static void main(String[] args) {CustomThread thread1 = new CustomThread("Task-1");CustomThread thread2 = new CustomThread("Task-2");thread1.start(); // 启动线程thread2.start();try {thread1.join(); // 等待线程结束thread2.join();} catch (InterruptedException e) {Thread.currentThread().interrupt();}System.out.println("所有任务执行完成");}
}

2.1.2 方式二: 实现Runnable

/*** 实现Runnable接口方式创建线程* 优点：避免单继承限制，更灵活* 缺点：不能直接返回结果*/
public class CustomRunnable implements Runnable {private final String taskName;public CustomRunnable(String taskName) {this.taskName = taskName;}@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + " 执行任务: " + taskName);try {Thread.sleep(800);System.out.println(Thread.currentThread().getName() + " 完成任务: " + taskName);} catch (InterruptedException e) {System.out.println(Thread.currentThread().getName() + " 被中断");Thread.currentThread().interrupt();}}public static void main(String[] args) {Thread thread1 = new Thread(new CustomRunnable("Task-A"), "RunnableThread-1");Thread thread2 = new Thread(new CustomRunnable("Task-B"), "RunnableThread-2");thread1.start();thread2.start();// 使用CountDownLatch等待线程完成CountDownLatch latch = new CountDownLatch(2);new Thread(() -> {try {thread1.join();latch.countDown();} catch (InterruptedException e) {Thread.currentThread().interrupt();}}).start();new Thread(() -> {try {thread2.join();latch.countDown();} catch (InterruptedException e) {Thread.currentThread().interrupt();}}).start();try {latch.await();System.out.println("所有Runnable任务执行完成");} catch (InterruptedException e) {Thread.currentThread().interrupt();}}
}

2.1.3 实现三: 实现 Callable 接口 + Future

/*** 实现Callable接口方式创建线程* 优点：可以返回结果和抛出异常* 缺点：需要配合ExecutorService使用*/
public class CustomCallable implements Callable<String> {private final String taskName;private final int executionTime;public CustomCallable(String taskName, int executionTime) {this.taskName = taskName;this.executionTime = executionTime;}@Overridepublic String call() throws Exception {System.out.println(Thread.currentThread().getName() + " 开始执行Callable任务: " + taskName);if (executionTime < 0) {throw new IllegalArgumentException("执行时间不能为负数");}Thread.sleep(executionTime);String result = "任务: " + taskName + " 完成，耗时: " + executionTime + "ms";System.out.println(Thread.currentThread().getName() + " " + result);return result;}public static void main(String[] args) {ExecutorService executor = Executors.newFixedThreadPool(3);// 提交多个Callable任务List<Future<String>> futures = new ArrayList<>();for (int i = 1; i <= 5; i++) {CustomCallable task = new CustomCallable("Task-" + i, i * 200);futures.add(executor.submit(task));}// 获取任务结果for (int i = 0; i < futures.size(); i++) {try {String result = futures.get(i).get(2, TimeUnit.SECONDS);System.out.println("获取到结果: " + result);} catch (InterruptedException e) {System.out.println("任务被中断");Thread.currentThread().interrupt();} catch (ExecutionException e) {System.out.println("任务执行异常: " + e.getCause().getMessage());} catch (TimeoutException e) {System.out.println("任务超时");}}executor.shutdown();try {if (!executor.awaitTermination(3, TimeUnit.SECONDS)) {executor.shutdownNow();}} catch (InterruptedException e) {executor.shutdownNow();Thread.currentThread().interrupt();}}
}

2.2 创建线程方式对比分析

特性继承 Thread实现 Runnable实现 Callable
继承限制受单继承限制无限制无限制
返回值无无有
异常处理只能在run()内处理只能在run()内处理可以抛出异常
资源占用每个任务需要新建线程可共享线程可共享线程
使用复杂度简单简单较复杂
适用场景简单独立任务需要资源共享的任务需要结果和异常处理的任务

三、线程同步机制

3.1 synchronized 关键字

/*** synchronized 同步方案* 内置锁，使用简单，JVM自动管理锁的获取和释放*/
public class SynchronizedExample {private int count = 0;private final Object lock = new Object();// 同步实例方法public synchronized void increment() {count++;}// 同步静态方法public static synchronized void staticIncrement() {// 类级别锁}// 同步代码块public void incrementWithBlock() {synchronized (lock) {count++;System.out.println(Thread.currentThread().getName() + " count: " + count);}}// 同步代码块（对象级别）public void incrementWithThis() {synchronized (this) {count++;}}public static void main(String[] args) throws InterruptedException {SynchronizedExample example = new SynchronizedExample();// 创建多个线程并发访问Thread[] threads = new Thread[10];for (int i = 0; i < threads.length; i++) {threads[i] = new Thread(() -> {for (int j = 0; j < 1000; j++) {example.incrementWithBlock();}}, "Thread-" + i);}// 启动所有线程for (Thread thread : threads) {thread.start();}// 等待所有线程完成for (Thread thread : threads) {thread.join();}System.out.println("最终结果: " + example.count); // 应该是10000}
}

在这里插入图片描述

3.2 Lock框架

/*** Lock 框架方案* 更灵活的锁机制，支持尝试锁、超时锁、可中断锁等*/
public class LockExample {private int count = 0;private final ReentrantLock lock = new ReentrantLock(true); // 公平锁private final ReadWriteLock rwLock = new ReentrantReadWriteLock();private final StampedLock stampedLock = new StampedLock();// 使用ReentrantLockpublic void incrementWithReentrantLock() {lock.lock(); // 获取锁try {count++;System.out.println(Thread.currentThread().getName() + " 写 count: " + count);} finally {lock.unlock(); // 必须在finally中释放锁}}// 尝试获取锁public boolean tryIncrement() {if (lock.tryLock()) { // 尝试获取锁，立即返回try {count++;return true;} finally {lock.unlock();}}return false;}// 使用ReadWriteLockpublic int getCountWithReadWriteLock() {rwLock.readLock().lock(); // 获取读锁try {return count;} finally {rwLock.readLock().unlock();}}// 使用StampedLock（乐观读）public int getCountWithStampedLock() {long stamp = stampedLock.tryOptimisticRead(); // 获取乐观读戳int currentCount = count;if (!stampedLock.validate(stamp)) { // 检查是否被修改stamp = stampedLock.readLock(); // 获取悲观读锁try {currentCount = count;} finally {stampedLock.unlockRead(stamp);}}return currentCount;}public static void main(String[] args) throws InterruptedException {LockExample example = new LockExample();// 写线程Thread writer = new Thread(() -> {for (int i = 0; i < 1000; i++) {example.incrementWithReentrantLock();try {Thread.sleep(1);} catch (InterruptedException e) {Thread.currentThread().interrupt();}}}, "Writer");// 读线程Thread reader = new Thread(() -> {for (int i = 0; i < 500; i++) {int value = example.getCountWithStampedLock();System.out.println(Thread.currentThread().getName() + " 读 count: " + value);try {Thread.sleep(2);} catch (InterruptedException e) {Thread.currentThread().interrupt();}}}, "Reader");writer.start();reader.start();writer.join();reader.join();System.out.println("最终结果: " + example.count);}
}

在这里插入图片描述

3.3 volatile关键字

package cn.tcmeta.repeat;import java.util.concurrent.atomic.AtomicInteger;/*** volatile 关键字方案* 保证可见性和有序性，但不保证原子性*/
public class VolatileExample {private volatile boolean running = true; // 保证可见性private volatile int count = 0; // 不保证原子性// 停止方法public void stop() {running = false;System.out.println("停止信号已发送");}// 工作方法public void work() {while (running) {// 模拟工作try {Thread.sleep(100);count++; // 这不是原子操作System.out.println(Thread.currentThread().getName() + " 工作中... count: " + count);} catch (InterruptedException e) {Thread.currentThread().interrupt();break;}}System.out.println(Thread.currentThread().getName() + " 停止工作");}// 使用Atomic类保证原子性private final AtomicInteger atomicCount = new AtomicInteger(0);public void atomicWork() {while (running) {try {Thread.sleep(100);int newValue = atomicCount.incrementAndGet();System.out.println(Thread.currentThread().getName() + " atomic count: " + newValue);} catch (InterruptedException e) {Thread.currentThread().interrupt();break;}}}static void main(String[] args) throws InterruptedException {VolatileExample example = new VolatileExample();// 启动工作线程Thread worker1 = new Thread(example::work, "Worker-1");Thread worker2 = new Thread(example::atomicWork, "Worker-2");worker1.start();worker2.start();// 运行3秒后停止Thread.sleep(3000);example.stop();worker1.join();worker2.join();System.out.println("普通count: " + example.count); // 可能不是预期值System.out.println("原子count: " + example.atomicCount.get()); // 准确值}
}

// ...
Worker-2 atomic count: 23
Worker-1 工作中... count: 23
Worker-1 工作中... count: 24
Worker-2 atomic count: 24
Worker-1 工作中... count: 25
Worker-2 atomic count: 25
Worker-1 工作中... count: 26
Worker-2 atomic count: 26
Worker-1 工作中... count: 27
Worker-2 atomic count: 27
Worker-1 工作中... count: 28
Worker-2 atomic count: 28
Worker-1 工作中... count: 29
Worker-2 atomic count: 29
停止信号已发送
Worker-1 工作中... count: 30
Worker-2 atomic count: 30
Worker-1 停止工作
普通count: 30
原子count: 30

3.4 同步机制对比分析

3.4 同步机制对比分析

特性synchronizedReentrantLockReadWriteLockStampedLockvolatile
锁类型内置锁显式锁读写锁戳锁变量修饰
公平性非公平可选公平可选公平非公平无
性能较好更好读多写少场景好最好最佳
功能基础丰富读写分离乐观读可见性
使用复杂度简单复杂复杂最复杂简单
适用场景简单同步复杂同步需求读多写少极高性能需求状态标志

四、线程池框架

4.1 Executor框架

package cn.tcmeta.repeat;import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.*;/*** Executor 框架方案* 线程池管理，避免频繁创建销毁线程的开销*/
public class ExecutorFrameworkExample {// 创建不同类型的线程池private final ExecutorService fixedPool = Executors.newFixedThreadPool(4);private final ExecutorService cachedPool = Executors.newCachedThreadPool();private final ExecutorService singlePool = Executors.newSingleThreadExecutor();private final ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(2);// 自定义线程池（推荐方式）private final ThreadPoolExecutor customPool = new ThreadPoolExecutor(4, // 核心线程数8, // 最大线程数60, TimeUnit.SECONDS, // 空闲线程存活时间new LinkedBlockingQueue<>(100), // 工作队列Executors.defaultThreadFactory(), // 线程工厂new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略);// 任务类static class ComputeTask implements Callable<Long> {private final int number;public ComputeTask(int number) {this.number = number;}@Overridepublic Long call() throws Exception {System.out.println(Thread.currentThread().getName() + " 计算: " + number);// 模拟计算任务long result = 0;for (int i = 1; i <= number; i++) {result += i;Thread.sleep(1); // 模拟计算耗时}return result;}}public void demonstratePools() throws InterruptedException, ExecutionException {// 使用固定大小线程池System.out.println("=== 固定大小线程池 ===");List<Future<Long>> futures = new ArrayList<>();for (int i = 1; i <= 10; i++) {futures.add(fixedPool.submit(new ComputeTask(i * 10)));}for (Future<Long> future : futures) {System.out.println("计算结果: " + future.get());}// 使用定时线程池System.out.println("=== 定时任务线程池 ===");scheduledPool.scheduleAtFixedRate(() -> {System.out.println(Thread.currentThread().getName() + " 定时任务执行: " + new Date());}, 1, 2, TimeUnit.SECONDS); // 延迟1秒，每2秒执行// 运行一段时间后关闭Thread.sleep(10000);shutdownPools();}private void shutdownPools() {fixedPool.shutdown();cachedPool.shutdown();singlePool.shutdown();scheduledPool.shutdown();customPool.shutdown();try {if (!fixedPool.awaitTermination(3, TimeUnit.SECONDS)) {fixedPool.shutdownNow();}} catch (InterruptedException e) {fixedPool.shutdownNow();Thread.currentThread().interrupt();}}static void main(String[] args) {ExecutorFrameworkExample example = new ExecutorFrameworkExample();try {example.demonstratePools();} catch (InterruptedException | ExecutionException e) {e.printStackTrace();Thread.currentThread().interrupt();}}
}

=== 固定大小线程池 ===
pool-1-thread-4 计算: 40
pool-1-thread-1 计算: 10
pool-1-thread-2 计算: 20
pool-1-thread-3 计算: 30
pool-1-thread-1 计算: 50
计算结果: 55
计算结果: 210
pool-1-thread-2 计算: 60
计算结果: 465
pool-1-thread-3 计算: 70
pool-1-thread-4 计算: 80
计算结果: 820
计算结果: 1275
pool-1-thread-1 计算: 90
pool-1-thread-2 计算: 100
计算结果: 1830
计算结果: 2485
计算结果: 3240
计算结果: 4095
计算结果: 5050
=== 定时任务线程池 ===
pool-4-thread-1 定时任务执行: Sat Aug 23 21:02:50 CST 2025
pool-4-thread-1 定时任务执行: Sat Aug 23 21:02:52 CST 2025
pool-4-thread-1 定时任务执行: Sat Aug 23 21:02:54 CST 2025

4.2 Fork/Join框架

package cn.tcmeta.repeat;import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.RecursiveTask;/*** Fork/Join 框架方案* 分治算法实现，适用于可分解的计算密集型任务*/
public class ForkJoinExample {// 递归任务：计算1到n的和static class SumTask extends RecursiveTask<Long> {private static final int THRESHOLD = 1000; // 阈值private final int start;private final int end;public SumTask(int start, int end) {this.start = start;this.end = end;}@Overrideprotected Long compute() {// 如果任务足够小，直接计算if (end - start <= THRESHOLD) {long sum = 0;for (int i = start; i <= end; i++) {sum += i;}return sum;}// 拆分任务int middle = (start + end) / 2;SumTask leftTask = new SumTask(start, middle);SumTask rightTask = new SumTask(middle + 1, end);// 异步执行子任务leftTask.fork();rightTask.fork();// 等待并合并结果return leftTask.join() + rightTask.join();}}// 递归动作：无需返回结果的任务static class PrintTask extends RecursiveAction {private static final int THRESHOLD = 10;private final int[] array;private final int start;private final int end;public PrintTask(int[] array, int start, int end) {this.array = array;this.start = start;this.end = end;}@Overrideprotected void compute() {if (end - start <= THRESHOLD) {for (int i = start; i < end; i++) {System.out.println(Thread.currentThread().getName() + ": " + array[i]);}} else {int middle = (start + end) / 2;PrintTask leftTask = new PrintTask(array, start, middle);PrintTask rightTask = new PrintTask(array, middle, end);invokeAll(leftTask, rightTask);}}}public static void main(String[] args) {// 创建ForkJoinPoolForkJoinPool pool = new ForkJoinPool();// 计算1到1000000的和SumTask task = new SumTask(1, 1000000);long result = pool.invoke(task);System.out.println("1到1000000的和: " + result);// 并行打印数组int[] array = new int[100];for (int i = 0; i < array.length; i++) {array[i] = i;}PrintAction printAction = new PrintAction(array, 0, array.length);pool.invoke(printAction);pool.shutdown();}
}

=== 固定大小线程池 ===
pool-1-thread-4 计算: 40
pool-1-thread-1 计算: 10
pool-1-thread-2 计算: 20
pool-1-thread-3 计算: 30
pool-1-thread-1 计算: 50
计算结果: 55
计算结果: 210
pool-1-thread-2 计算: 60
计算结果: 465
pool-1-thread-3 计算: 70
pool-1-thread-4 计算: 80
计算结果: 820
计算结果: 1275
pool-1-thread-1 计算: 90
pool-1-thread-2 计算: 100
计算结果: 1830
计算结果: 2485
计算结果: 3240
计算结果: 4095
计算结果: 5050
=== 定时任务线程池 ===
pool-4-thread-1 定时任务执行: Sat Aug 23 21:02:50 CST 2025
pool-4-thread-1 定时任务执行: Sat Aug 23 21:02:52 CST 2025

五、并发集合与工具类

5.1 并发集合框架

package cn.tcmeta.repeat;import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.LinkedBlockingQueue;/*** 并发集合框架方案* 线程安全的集合实现，避免显式同步*/
public class ConcurrentCollectionsExample {public static void demonstrateConcurrentCollections() {// 1. ConcurrentHashMap - 并发哈希表ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();// 并发putIfAbsentconcurrentMap.putIfAbsent("key1", 1);concurrentMap.putIfAbsent("key1", 2); // 不会替换// 使用compute方法原子更新concurrentMap.compute("key2", (k, v) -> v == null ? 1 : v + 1);// 2. CopyOnWriteArrayList - 写时复制列表CopyOnWriteArrayList<String> copyOnWriteList = new CopyOnWriteArrayList<>();copyOnWriteList.add("item1");copyOnWriteList.add("item2");// 迭代过程中可以修改（迭代器使用快照）for (String item : copyOnWriteList) {if (item.equals("item1")) {copyOnWriteList.add("item3"); // 不会影响当前迭代}}// 3. BlockingQueue - 阻塞队列BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<>(10);// 生产者线程Thread producer = new Thread(() -> {try {for (int i = 0; i < 20; i++) {String item = "item-" + i;blockingQueue.put(item); // 队列满时阻塞System.out.println("生产: " + item);Thread.sleep(100);}} catch (InterruptedException e) {Thread.currentThread().interrupt();}});// 消费者线程Thread consumer = new Thread(() -> {try {for (int i = 0; i < 20; i++) {String item = blockingQueue.take(); // 队列空时阻塞System.out.println("消费: " + item);Thread.sleep(150);}} catch (InterruptedException e) {Thread.currentThread().interrupt();}});producer.start();consumer.start();try {producer.join();consumer.join();} catch (InterruptedException e) {Thread.currentThread().interrupt();}}static void main(String[] args) {demonstrateConcurrentCollections();}
}

5.2 并发工具类

/*** 并发工具类方案* 提供高级同步机制*/
public class ConcurrencyToolsExample {public static void demonstrateTools() throws InterruptedException {// 1. CountDownLatch - 倒计时门闩CountDownLatch startLatch = new CountDownLatch(1);CountDownLatch endLatch = new CountDownLatch(3);for (int i = 0; i < 3; i++) {new Thread(() -> {try {System.out.println(Thread.currentThread().getName() + " 等待开始");startLatch.await(); // 等待开始信号System.out.println(Thread.currentThread().getName() + " 开始工作");Thread.sleep(1000);System.out.println(Thread.currentThread().getName() + " 完成工作");endLatch.countDown(); // 完成计数减一} catch (InterruptedException e) {Thread.currentThread().interrupt();}}).start();}Thread.sleep(1000);System.out.println("准备开始...");startLatch.countDown(); // 释放所有等待线程endLatch.await(); // 等待所有线程完成System.out.println("所有任务完成");// 2. CyclicBarrier - 循环屏障CyclicBarrier barrier = new CyclicBarrier(3, () -> {System.out.println("所有线程到达屏障，执行屏障操作");});for (int i = 0; i < 3; i++) {new Thread(() -> {try {System.out.println(Thread.currentThread().getName() + " 到达屏障");barrier.await(); // 等待其他线程System.out.println(Thread.currentThread().getName() + " 继续执行");} catch (Exception e) {e.printStackTrace();}}).start();}// 3. Semaphore - 信号量Semaphore semaphore = new Semaphore(2); // 允许2个并发for (int i = 0; i < 5; i++) {new Thread(() -> {try {semaphore.acquire(); // 获取许可System.out.println(Thread.currentThread().getName() + " 获得许可，执行中");Thread.sleep(2000);semaphore.release(); // 释放许可System.out.println(Thread.currentThread().getName() + " 释放许可");} catch (InterruptedException e) {Thread.currentThread().interrupt();}}).start();}}public static void main(String[] args) throws InterruptedException {demonstrateTools();}
}

六、Java 并发编程最佳实践总结

6.1 方案选择指南

场景推荐方案原因
简单同步synchronized使用简单，JVM优化
复杂锁需求ReentrantLock功能丰富，灵活性高
读多写少ReadWriteLock/StampedLock提高读并发性能
状态标志volatile轻量级可见性保证
任务执行Executor框架线程池管理，资源可控
计算密集型Fork/Join框架自动任务分解，充分利用多核
数据共享并发集合线程安全，避免显式同步
线程协调并发工具类高级同步原语

6.2 实践经验总结

  1. 优先使用高级抽象：尽量使用Executor、并发集合等高级API，避免直接操作线程
  2. 合理配置线程池：根据任务类型（CPU密集型/IO密集型）配置合适的线程池参数
  3. 避免死锁：按固定顺序获取锁，使用tryLock带超时
  4. 注意资源清理：正确关闭线程池和释放资源
  5. 使用不可变对象：避免同步需求，提高线程安全性
  6. 合理使用本地变量：减少共享数据，降低同步需求
  7. 性能监控：使用JMX等工具监控线程状态和性能指标

6.3 常见陷阱与避免

  1. 内存可见性：正确使用volatile或同步确保可见性
  2. 竞态条件：使用原子变量或同步避免竞态条件
  3. 上下文切换开销：避免创建过多线程，使用线程池
  4. 死锁：避免嵌套锁，使用定时锁
  5. 活锁：引入随机性避免重复冲突
  6. 线程泄漏：确保正确关闭和清理资源

Java并发编程是一个复杂但强大的领域，正确使用并发工具和技术可以显著提高程序性能和响应能力。根据具体需求选择合适的并发方案，并遵循最佳实践，才能构建出高效、可靠的并发应用程序。

http://www.dtcms.com/a/352249.html

相关文章：

  • 控制系统仿真之基础知识（一）
  • Nat Commun｜“铃铛病”的空间多组学揭示基质细胞在疾病发生中的核心地位
  • 广告推荐模型1：逻辑回归（Logistic Regression，LR）
  • WebSocket实时通信系统——js技能提升
  • Linux 详谈软硬链接
  • 如何从零开始学习黑客技术？网络安全入门指南
  • Linux 系统配置 YUM 软件仓库
  • 【大语言模型 22】Tokenization深度技术：BPE、WordPiece、SentencePiece
  • 【Redisson】redis最佳实践-RedissonUtils+Caffeine
  • 【机器人】2025年人形机器人看护革命：AI驱动的医疗变革先锋
  • 小知识-为什么处理异步数据渲染需要async await 搭配Promise.all实现？
  • 昆仑资本完成对国产工业操作系统龙头企业光亚鸿道的投资
  • MYSQL递归
  • mysql优化-mysql索引下推
  • Python 将十进制转换为十六进制
  • Linux命令详解+示例（炫彩超全）
  • 2025秋招季：AI笔试破解大规模招聘难题
  • MySQL 面试题系列（四）
  • Pandas 分组聚合进阶：过滤与 apply
  • 【人工智能】神经网络的优化器optimizer（三）：RMSProp动态自适应学习率优化器
  • java自定义注解实现
  • 开发electron时候Chromium 报 Not allowed to load local resource → 空白页。
  • 在使用spring ai进行llm处理的rag的时候，选择milvus还是neo4j呢？
  • gorm 枚举查询遇到的问题
  • 【Python】Python日志模块完全指南：从配置到常见错误排查
  • 深入OpenHarmony后台任务“黑匣子”：BackgroundTaskMgr框架全栈解析与实战避坑指南
  • C#编程：贪吃蛇游戏
  • 使用linux+javascript+html+mysql+nodejs+npm+express等构建信息资料采集系统
  • FreeRTOS 同步互斥与任务协作 学习笔记
  • 【Protues仿真】定时器