摘要 ：本文系统解析Java多线程全体系知识，涵盖线程实现原理、并发工具实战、锁机制底层实现、线程池参数调优策略，并提供20+可运行代码片段。附内存模型原理与性能优化指南。
线程基础与并发模型深度解析 三种线程实现方式底层对比 线程状态机与调度策略全解 锁机制实现原理与性能对比 生产者-消费者模式的6种实现方案 线程池7大参数配置与拒绝策略实战 JMM内存模型与happens-before规则 并发编程常见陷阱与性能调优 高频面试题深度剖析 ┌───────────────┐ ┌───────────────┐
│ CPU Core 1 │ │ CPU Core 2 │
│ L1 Cache │ │ L1 Cache │
│ L2 Cache │ │ L2 Cache │
└───────┬───────┘ └───────┬───────┘│ │└───────共享L3 Cache───────┘│主内存（DRAM）
缓存一致性协议（MESI） ：保证多核CPU缓存一致性伪共享（False Sharing） ：不同CPU核心修改同一缓存行的不同变量导致性能下降解决方案 ：@Contended注解进行缓存行填充
class Counter { private int value = 0 ; public void increment ( ) { value++ ; }
}
可见性问题 ：工作内存与主内存不一致原子性问题 ：非原子操作的中间状态暴露有序性问题 ：指令重排序导致执行顺序改变特性 继承Thread 实现Runnable Callable+Future 返回值支持 ❌ ❌ ✔️（通过Future获取） 异常处理 只能try/catch 同左 可抛出受检异常 资源消耗 每次new线程 可复用Runnable实例 配合线程池使用 扩展性 受Java单继承限制 无限制 无限制
public class FutureTask < V > implements RunnableFuture < V > { private volatile int state; private Callable < V > ; private Object outcome; public void run ( ) { try { Callable < V > = callable; if ( c != null && state == NEW ) { V result = c. call ( ) ; set ( result) ; } } catch ( Throwable ex) { setException ( ex) ; } }
}
状态流转 ：NEW -> COMPLETING -> NORMAL内存语义 ：通过volatile变量state保证可见性调度类型 抢占式调度 协作式调度 实现机制 由OS决定线程切换 线程主动让出CPU 响应速度 高 低 公平性 相对公平 依赖线程自觉性 Java实现 默认调度方式 yield()实现有限协作
| -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- - |
| Mark Word ( 64 bits) | State |
| -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- - |
| unused: 25 | identity_hashcode: 31 | unused: 1 | age: 4 | 01 | Normal |
| ptr_to_lock_record: 62 | 00 | Lightweight Locked |
| ptr_to_heavyweight_monitor: 62 | 10 | Heavyweight Locked |
| | 11 | Marked for GC |
锁升级过程 ：无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁锁消除 ：JIT编译器对不可能存在竞争的锁进行消除锁粗化 ：将连续的加锁解锁操作合并为单个锁操作特性 ReentrantLock synchronized 锁获取方式 显式lock()/unlock() 隐式代码块 尝试非阻塞获取锁 tryLock() 不支持 公平锁 支持（构造函数指定） 不支持 条件变量 支持多个Condition 单一wait/notify 性能 高竞争场景更优 低竞争场景更优
class BoundedBuffer { final Object [ ] items = new Object [ 100 ] ; int putptr, takeptr, count; public synchronized void put ( Object x) throws InterruptedException { while ( count == items. length) wait ( ) ; items[ putptr] = x; if ( ++ putptr == items. length) putptr = 0 ; count++ ; notifyAll ( ) ; } public synchronized Object take ( ) throws InterruptedException { while ( count == 0 ) wait ( ) ; Object x = items[ takeptr] ; if ( ++ takeptr == items. length) takeptr = 0 ; count-- ; notifyAll ( ) ; return x; }
}
class BoundedBuffer { final Lock lock = new ReentrantLock ( ) ; final Condition notFull = lock. newCondition ( ) ; final Condition notEmpty = lock. newCondition ( ) ; public void put ( Object x) throws InterruptedException { lock. lock ( ) ; try { while ( count == items. length) notFull. await ( ) ; notEmpty. signal ( ) ; } finally { lock. unlock ( ) ; } }
}
队列类型 吞吐量（ops/ms） 延迟（ns） 适用场景 ArrayBlockingQueue 500,000 2,000 通用场景 LinkedBlockingQueue 200,000 10,000 无界队列场景 Disruptor 25,000,000 50 高频交易系统
ThreadPoolExecutor executor = new ThreadPoolExecutor ( . . . ) ;
executor. setCorePoolSize ( 20 ) ;
executor. setMaximumPoolSize ( 100 ) ;
executor. setRejectedExecutionHandler ( new ThreadPoolExecutor. AbortPolicy ( ) ) ;
指标 获取方法 健康标准 活跃线程数 executor.getActiveCount() <= maximumPoolSize 任务队列积压 executor.getQueue().size() <= queue.capacity 已完成任务数 executor.getCompletedTaskCount() 持续增长 拒绝任务数 自定义RejectedPolicy统计 接近0
IO密集型 ：线程数 = CPU核心数 * 目标CPU利用率 * (1 + 平均等待时间/平均计算时间)CPU密集型 ：线程数 = CPU核心数 + 1混合型任务 ：线程数 = (IO耗时占比 / CPU耗时占比) * CPU核心数屏障类型 作用范围 典型应用场景 LoadLoad屏障 读-读顺序 volatile读操作后 StoreStore屏障 写-写顺序 volatile写操作前 LoadStore屏障 读-写顺序 普通变量访问 StoreLoad屏障 写-读顺序（全能屏障） volatile写操作后
程序顺序规则 ：单线程内的执行顺序锁规则 ：解锁操作先于后续加锁操作volatile规则 ：写操作先于后续读操作线程启动规则 ：Thread.start()先于线程内任何操作线程终止规则 ：线程内所有操作先于Thread.join()中断规则 ：interrupt()调用先于检测到中断案例1：错误使用SimpleDateFormat
private static SimpleDateFormat sdf = new SimpleDateFormat ( "yyyy-MM-dd" ) ;
private static ThreadLocal < DateFormat > = ThreadLocal . withInitial ( ( ) -> new SimpleDateFormat ( "yyyy-MM-dd" )
) ;
案例2：不安全的双重检查锁定
if ( instance == null ) { synchronized ( Singleton . class ) { if ( instance == null ) { instance = new Singleton ( ) ; } }
}
避免过度同步（缩小同步块范围） 使用并发容器替代同步容器 优先使用无锁数据结构（Atomic类） 注意上下文切换开销（线程数不宜过多） 使用线程池时设置合理队列容量 方案1 ：LongAdder（分段锁思想）方案2 ：AtomicLong（CAS自旋）方案3 ：CompletableFuture异步聚合 +----------------+| Sync Queue || (CLH变体) |+-------+--------+|+-------v--------+| Condition || Queue |+----------------+
核心机制 ： 通过CAS维护state状态 CLH队列管理等待线程 模板方法模式实现锁语义 jstack ：分析线程状态分布Arthas ：监控线程池实时指标Prometheus+Grafana ：建立长期监控看板 实战项目推荐 ：
实现一个支持动态扩缩容的线程池 开发高吞吐量异步日志框架 设计分布式环境下的限流组件
版权声明 ：本文核心内容基于Oracle官方文档与《Java并发编程实战》，转载请注明出处并附原文链接。
