Rust并发编程实战-多线程武侠对战系统

// 游戏状态使用 RwLock，支持多读单写
let game_state = Arc::new(RwLock::new(GameState::new()));

// 读操作：多个线程可同时读取
let state = game_state.read().unwrap();  // 共享读锁
let hp = state.characters["张无忌"].hp;

// 写操作：独占写锁
let mut state = game_state.write().unwrap();  // 独占写锁
state.characters.get_mut("张无忌").unwrap().hp -= 10;

// 客户端列表使用 Mutex 保护
let clients = Arc::new(Mutex::new(Vec::<mpsc::Sender<String>>::new()));

// 添加客户端（自动加锁）
{
    let mut clients = clients.lock().unwrap();  // 自动获取锁
    clients.push(new_client);
}  // 锁自动释放（RAII）

// 广播消息（快速加锁）
let clients = clients.lock().unwrap();
for tx in clients.iter() {
    let _ = tx.send(msg.clone());
}  // 锁自动释放

// 主线程：接受连接
let listener = TcpListener::bind("127.0.0.1:8888")?;

// 游戏逻辑线程：独立处理游戏规则
thread::spawn(move || {
    game_logic_thread(game_state, rx_actions, tx_broadcast);
});

// 广播线程：专门负责消息分发
thread::spawn(move || {
    broadcast_thread(rx_broadcast, clients);
});

// 客户端处理线程：每个客户端独立线程
for stream in listener.incoming() {
    thread::spawn(move || {
        handle_client(stream, player_name, game_state, tx_actions, rx_client);
    });
}

主线程（接受连接）
  ├─→ 游戏逻辑线程（处理游戏规则）
  ├─→ 广播线程（消息分发）
  └─→ 客户端处理线程（每个客户端独立线程）

// 创建类型安全的通道
let (tx_actions, rx_actions) = mpsc::channel::<PlayerAction>();

// 发送消息（类型检查）
tx_actions.send(PlayerAction {
    player_name: "张无忌".to_string(),
    action: "九阳神功".to_string(),
    target: None,
}).unwrap();

// 接收消息（带超时，避免死锁）
match rx_actions.recv_timeout(Duration::from_secs(30)) {
    Ok(action) => { /* 处理操作 */ }
    Err(RecvTimeoutError::Timeout) => { /* 超时处理 */ }
}

// 非阻塞接收
while let Ok(msg) = rx_network.try_recv() {
    // 处理消息
}

// 创建通道
let (tx_input, rx_input) = mpsc::channel::<String>();
let (tx_network, rx_network) = mpsc::channel::<String>();

// 线程1：读取标准输入（独立线程）
thread::spawn(move || {
    let stdin = io::stdin();
    let mut reader = BufReader::new(stdin);
    loop {
        let mut input = String::new();
        if reader.read_line(&mut input).is_ok() {
            tx_input.send(input.trim().to_string() + "\n").ok();
        }
    }
});

// 线程2：读取网络消息（独立线程）
thread::spawn(move || {
    let mut reader = BufReader::new(stream);
    loop {
        let mut msg = String::new();
        if reader.read_line(&mut msg).is_ok() {
            tx_network.send(msg).ok();
        }
    }
});

// 主线程：非阻塞协调处理
loop {
    // 非阻塞接收网络消息
    if let Ok(msg) = rx_network.try_recv() {
        print!("{}", msg);
        io::stdout().flush().unwrap();
    }
    
    // 非阻塞接收用户输入
    if let Ok(input) = rx_input.try_recv() {
        writer.write_all(input.as_bytes()).unwrap();
        writer.flush().unwrap();
    }
    
    thread::sleep(Duration::from_millis(10));
}

// ✅ Rust：编译时检查，保证内存安全
let data = Arc::new(Mutex::new(0));
let data_clone = data.clone();  // Arc 克隆，引用计数 +1

thread::spawn(move || {
    // move 关键字：数据所有权转移，原线程无法再使用
    let mut guard = data_clone.lock().unwrap();
    *guard += 1;
    // 锁在作用域结束时自动释放（RAII）
});  // data_clone 在这里被释放，引用计数 -1

// ❌ 其他语言（如 C++）：运行时可能崩溃
// - 悬垂指针
// - 双重释放
// - 内存泄漏

// Rust 的并发原语编译后几乎没有运行时开销
let (tx, rx) = mpsc::channel::<PlayerAction>();

// 编译后：
// - Channel 使用无锁队列（lock-free queue）
// - 无 GC 暂停
// - 无运行时类型检查
// - 直接编译为机器码

// 性能对比（读多写少场景）：
// RwLock::read()  - 多个线程可同时读取，性能接近无锁
// Mutex::lock()   - 每次都需要互斥，性能略低

// ✅ Rust：编译时检查，防止数据竞争
let game_state = Arc::new(RwLock::new(GameState::new()));

// 场景1：同时获取两个可变引用 - 编译错误
let mut actor = game_state.write().unwrap();
let mut opponent = game_state.write().unwrap();  // ❌ 编译错误！

// 场景2：正确的做法 - 分阶段获取
{
    let mut actor = game_state.write().unwrap();
    // 修改 actor
}  // 锁自动释放
{
    let mut opponent = game_state.write().unwrap();
    // 修改 opponent
}  // 锁自动释放

// 场景3：忘记释放锁 - 编译时检查作用域
{
    let guard = mutex.lock().unwrap();
    // 如果忘记释放，作用域结束时自动释放（RAII）
}

// 示例：游戏状态更新（完美体现三大优势）

// 1. 内存安全：Arc 确保数据在所有线程退出前存在
let game_state = Arc::new(RwLock::new(GameState::new()));

// 2. 高性能：RwLock 允许多个线程同时读取
let status = {
    let state = game_state.read().unwrap();  // 共享读锁，多个线程可同时读取
    state.get_status_string()  // 快速读取，无锁竞争
};  // 读锁自动释放

// 3. 并发可靠：编译时检查，防止数据竞争
{
    let mut state = game_state.write().unwrap();  // 独占写锁
    state.process_action(&action);  // 安全修改
}  // 写锁自动释放（RAII）

// 如果尝试同时获取两个写锁，编译时会报错：
// let mut s1 = game_state.write().unwrap();
// let mut s2 = game_state.write().unwrap();  // ❌ 编译错误！

多线程对战示例/
├── server/              # 服务器
│   ├── Cargo.toml
│   └── src/
│       └── main.rs
├── client_hero/         # 张无忌客户端
│   ├── Cargo.toml
│   └── src/
│       └── main.rs
└── client_villain/      # 成昆客户端
    ├── Cargo.toml
    └── src/
        └── main.rs

cd server
cargo run

cd client_hero
cargo run

cd client_villain
cargo run