第三部分：并发与异步编程模型 —— 驾驭多核时代的力量

现代计算机多核处理器普及，充分利用并发和并行是提升程序性能的关键。但并发编程也带来了数据竞争、死锁、线程安全等复杂问题。深度掌握语言的并发模型，能够安全高效地编写并发程序。

3.1 并发的基本概念：并行 vs 并发，线程 vs 协程
并发：多个任务在逻辑上同时执行（交替进行）。

并行：多个任务在物理上同时执行（需要多核）。

线程：操作系统调度的最小单位，切换成本较高（几微秒到几十微秒）。

协程：用户态轻量级线程，由语言运行时调度，切换成本极低（纳秒级），可以创建数十万个。

不同语言提供的并发原语：

3.2 异步编程模型：回调 → Promise → async/await 的演进
异步编程允许程序在等待I/O时执行其他任务，避免线程阻塞。理解异步模型是编写高响应、高吞吐应用的基础。

示例15：JavaScript的Promise链与async/await

// 模拟异步操作
function fetchUser(id) {
    return new Promise(resolve => {
        setTimeout(() => resolve({ id, name: `User${id}` }), 100);
    });
}

function fetchPosts(userId) {
    return new Promise(resolve => {
        setTimeout(() => resolve([`Post1 by ${userId}`, `Post2 by ${userId}`]), 100);
    });
}

// Promise链式调用
fetchUser(1)
    .then(user => {
        console.log(user.name);
        return fetchPosts(user.id);
    })
    .then(posts => {
        console.log(posts);
    })
    .catch(err => console.error(err));

// async/await 更清晰的写法
async function displayUserContent(id) {
    try {
        const user = await fetchUser(id);
        console.log(user.name);
        const posts = await fetchPosts(user.id);
        console.log(posts);
    } catch (err) {
        console.error(err);
    }
}
displayUserContent(2);

深度解释：async函数返回一个Promise，await会暂停当前函数的执行，直到Promise完成，但不会阻塞事件循环。这比回调地狱（Callback Hell）可读性高得多。

示例16：Python的asyncio实现并发网络请求

import asyncio
import aiohttp

async def fetch_url(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    urls = [
        'http://example.com',
        'http://example.org',
        'http://example.net',
    ]
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        for url, html in zip(urls, results):
            print(f"{url}: {len(html)} bytes")

asyncio.run(main())

关键点：asyncio.gather并发执行多个协程。在等待网络响应时，事件循环可以切换到其他协程，实现高效I/O并发。

3.3 多线程同步：锁、原子操作、并发集合
当多个线程共享可变状态时，必须使用同步机制来保证数据一致性。

示例17：Java中的线程安全计数器比较

// 非线程安全
class UnsafeCounter {
    private int count = 0;
    public void increment() { count++; }  // 多线程下丢失更新
    public int get() { return count; }
}

// 使用synchronized
class SynchronizedCounter {
    private int count = 0;
    public synchronized void increment() { count++; }
    public synchronized int get() { return count; }
}

// 使用AtomicInteger（无锁CAS）
import java.util.concurrent.atomic.AtomicInteger;
class AtomicCounter {
    private AtomicInteger count = new AtomicInteger(0);
    public void increment() { count.incrementAndGet(); }
    public int get() { return count.get(); }
}

// 使用LongAdder（高并发下更好）
import java.util.concurrent.atomic.LongAdder;
class AdderCounter {
    private LongAdder count = new LongAdder();
    public void increment() { count.increment(); }
    public long get() { return count.sum(); }
}

性能对比：synchronized适合低竞争场景；AtomicInteger基于CAS，没有锁的开销，但在高竞争下可能自旋；LongAdder通过分段计数进一步减少竞争。进阶开发者会根据场景选择合适的同步工具。

示例18：Go的Mutex和RWMutex

type SafeCounter struct {
    mu sync.Mutex
    m  map[string]int
}

func (c *SafeCounter) Inc(key string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.m[key]++
}

func (c *SafeCounter) Value(key string) int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.m[key]
}

// 读多写少场景使用RWMutex，允许并发读
type SafeMap struct {
    mu sync.RWMutex
    m  map[string]string
}

func (s *SafeMap) Get(key string) string {
    s.mu.RLock()
    defer s.mu.RUnlock()
    return s.m[key]
}

3.4 数据竞争与死锁的检测与避免
数据竞争：多个线程同时访问同一内存位置，至少有一个是写操作，且没有同步。Go语言内置了数据竞争检测器：go test -race。

死锁：两个或多个线程互相等待对方持有的锁，导致永久阻塞。

示例19：Java死锁示例及解决方法

public class DeadlockDemo {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized(lock1) {
            sleep(100);  // 模拟工作
            synchronized(lock2) {
                System.out.println("method1 done");
            }
        }
    }

    public void method2() {
        synchronized(lock2) {
            sleep(100);
            synchronized(lock1) {
                System.out.println("method2 done");
            }
        }
    }

    private void sleep(int ms) { try { Thread.sleep(ms); } catch(Exception e) {} }

    public static void main(String[] args) {
        DeadlockDemo demo = new DeadlockDemo();
        new Thread(demo::method1).start();
        new Thread(demo::method2).start();
    }
}

避免死锁的原则：

固定锁顺序：总是以相同的顺序获取锁。例如，总是先获取lock1再获取lock2。

使用超时尝试：tryLock(timeout)（Java），如果获取失败则释放已持有的锁并重试。

减少锁粒度：使用并发集合（ConcurrentHashMap）或无锁数据结构。

使用更高级的同步工具：如java.util.concurrent的Semaphore、CountDownLatch等。
来源：
https://zlpow.cn/