1. 多线程与高并发基础概念
现代计算机系统早已从单核时代迈入多核时代，如何充分利用硬件资源成为开发者必须面对的课题。多线程编程允许单个进程内并发执行多个任务流，而高并发则描述了系统同时处理大量请求的能力。这两者结合，构成了现代高性能应用的基石。
1.1 线程的本质与实现
线程是操作系统调度的最小单位，共享进程的内存空间但拥有独立的执行栈。在Linux系统中，通过pthread_create()创建的线程实质上是轻量级进程（LWP），其创建成本约为进程的1/10。Windows的线程实现则采用线程内核对象+线程环境块（TEB）的结构，上下文切换时需要保存/恢复约300个寄存器状态。
不同语言对线程的封装各有特点：
- Java的Thread类实质是对操作系统线程的JVM级抽象
- Go语言的goroutine则是用户态线程，通过GMP调度模型实现
- Python由于GIL限制，多线程更适合I/O密集型场景
实际测试表明：在16核服务器上创建1000个Java线程会导致约15%的CPU时间消耗在线程切换上，而同等数量的goroutine切换损耗不到2%
1.2 并发与并行的区别
并发（Concurrency）强调任务处理的逻辑同时性，可能是时间片轮转的假象；并行（Parallelism）则要求物理上的同时执行。举例来说：
- 单核CPU通过快速切换实现并发浏览网页+听音乐
- 多核CPU可以真正并行运行多个计算密集型任务
2. 多线程编程核心技术
2.1 线程安全与同步机制
当多个线程访问共享资源时，会出现竞态条件（Race Condition）。解决这类问题的核心在于建立happens-before关系，常用手段包括：
2.1.1 互斥锁实现
// Java示例 private final Object lock = new Object(); public void transfer(Account from, Account to, int amount) { synchronized(lock) { // 获取内置锁 from.debit(amount); to.credit(amount); } }C++中推荐使用std::mutex配合std::lock_guard：
std::mutex mtx; void safe_push(std::vector<int>& vec, int val) { std::lock_guard<std::mutex> lg(mtx); vec.push_back(val); }2.1.2 无锁编程技术
CAS（Compare-And-Swap）是原子操作的基石，现代CPU通常提供对应的指令支持：
; x86汇编实现 lock cmpxchg [mem], reg ; 原子比较交换Java中的AtomicInteger即基于此实现：
AtomicInteger counter = new AtomicInteger(0); counter.incrementAndGet(); // 线程安全的自增2.2 线程间通信
2.2.1 条件变量范式
# Python示例 import threading condition = threading.Condition() queue = [] def producer(): with condition: queue.append("new item") condition.notify_all() def consumer(): with condition: while not queue: condition.wait() item = queue.pop()2.2.2 消息队列实践
Go语言的channel是更高级的抽象：
ch := make(chan int, 100) // 缓冲通道 go func() { ch <- 42 // 发送 }() value := <-ch // 接收3. 高并发系统设计
3.1 I/O多路复用模型
以Java NIO为例的Reactor模式实现：
Selector selector = Selector.open(); ServerSocketChannel ssc = ServerSocketChannel.open(); ssc.bind(new InetSocketAddress(8080)); ssc.configureBlocking(false); ssc.register(selector, SelectionKey.OP_ACCEPT); while (true) { selector.select(); // 阻塞直到有事件 Set<SelectionKey> keys = selector.selectedKeys(); for (SelectionKey key : keys) { if (key.isAcceptable()) { // 处理新连接 } else if (key.isReadable()) { // 处理读事件 } } keys.clear(); }3.2 线程池优化策略
参数配置经验公式：
- 计算密集型：核心线程数 = CPU核数 + 1
- I/O密集型：核心线程数 = CPU核数 × (1 + 平均等待时间/平均计算时间)
Java中的ThreadPoolExecutor配置示例：
ThreadPoolExecutor executor = new ThreadPoolExecutor( 4, // 核心线程数 16, // 最大线程数 60, TimeUnit.SECONDS, // 空闲线程存活时间 new LinkedBlockingQueue<>(1000), // 任务队列 new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略 );4. 常见问题排查
4.1 死锁检测
使用jstack工具分析Java线程转储：
jstack -l <pid> > thread_dump.txt典型死锁特征：
Found one Java-level deadlock: ============================= "Thread-1": waiting to lock monitor 0x00007f0134003b58 (object 0x000000076ab45c98...) which is held by "Thread-0" "Thread-0": waiting to lock monitor 0x00007f0134003e18 (object 0x000000076ab45ca8...) which is held by "Thread-1"4.2 性能瓶颈定位
使用Async Profiler进行采样分析：
./profiler.sh -d 60 -f flamegraph.html <pid>典型优化方向：
- 减少锁粒度：用ConcurrentHashMap替代synchronizedMap
- 避免锁嵌套：按照固定顺序获取多个锁
- 使用读写锁：ReadWriteLock适合读多写少场景
5. 现代并发模型演进
5.1 协程实践
Kotlin的协程实现：
fun main() = runBlocking { val job1 = launch(Dispatchers.IO) { delay(1000) println("World") } println("Hello") job1.join() }5.2 Actor模型
Akka框架示例：
class Greeter extends Actor { def receive = { case "hello" => println("Hello back!") case _ => println("Unknown message") } } val system = ActorSystem("MySystem") val greeter = system.actorOf(Props[Greeter](), "greeter") greeter ! "hello"6. 实战经验总结
在电商秒杀系统开发中，我们采用分层削峰策略：
- 前端层：随机丢包+按钮置灰
- 网关层：令牌桶限流（10000 QPS）
- 服务层：Redis预减库存+本地缓存
- 数据层：MySQL队列+批量更新
关键配置参数：
# Tomcat优化 server.tomcat.max-threads=800 server.tomcat.accept-count=1000 # Redis连接池 spring.redis.lettuce.pool.max-active=500 spring.redis.lettuce.pool.max-wait=200ms线程上下文切换的代价往往被低估。实测表明：当系统负载达到70%时，每增加1000个线程会导致吞吐量下降8-12%。建议通过vmstat 1监控cs（context switch）字段，正常应低于5000次/秒。
