Rust 游戏服务端性能优化：从内存布局到无锁并发的实战方案

// ❌ 不好的布局：内存分散，缓存命中率低
#[derive(Debug)]
struct PlayerBad {
    id: u64,      // 8 bytes
    name: String, // 24 bytes (堆分配)
    x: f32,       // 4 bytes
    y: f32,       // 4 bytes
    hp: i32,      // 4 bytes
    mp: i32,      // 4 bytes
    inventory: Vec<Item>, // 24 bytes (堆分配)
}

// ✅ 好的布局：SOA (Structure of Arrays)
struct Players {
    ids: Vec<u64>,
    xs: Vec<f32>,
    ys: Vec<f32>,
    hps: Vec<i32>,
    mps: Vec<i32>,
}

#[repr(C)]
struct Packet {
    msg_type: u16,  // 2 bytes
    // 编译器插入 6 bytes padding
    timestamp: u64, // 8 bytes，需要 8 字节对齐
    player_id: u32, // 4 bytes
    // 编译器插入 4 bytes padding
    position: [f64; 3], // 24 bytes，需要 8 字节对齐
}
// 实际大小：2 + 6 + 8 + 4 + 4 + 24 = 48 bytes

#[repr(C)]
struct PacketOptimized {
    timestamp: u64,     // 8 bytes (offset 0)
    position: [f64; 3], // 24 bytes (offset 8)
    player_id: u32,     // 4 bytes (offset 32)
    msg_type: u16,      // 2 bytes (offset 36)
    // 仅需 2 bytes padding (offset 38-39)
}
// 实际大小：40 bytes（节省 8 bytes）

use crossbeam::queue::SegQueue;

// 多生产者-多消费者消息队列，无需锁
let msg_queue: Arc<SegQueue<GameMessage>> = Arc::new(SegQueue::new());

// 生产者线程（网络 IO 线程）
let q = Arc::clone(&msg_queue);
std::thread::spawn(move || {
    loop {
        let msg = recv_from_network();
        q.push(msg);
    }
});

// 消费者线程（逻辑处理线程）
let q = Arc::clone(&msg_queue);
std::thread::spawn(move || {
    loop {
        if let Some(msg) = q.pop() {
            process_message(msg);
        }
    }
});

use std::sync::atomic::{AtomicPtr, Ordering};
use std::sync::Arc;

struct GameConfig {
    ptr: AtomicPtr<Vec<SkillConfig>>,
}

impl GameConfig {
    fn get_skills(&self) -> Arc<Vec<SkillConfig>> {
        // Acquire 保证看到完整的写操作
        let raw = self.ptr.load(Ordering::Acquire);
        // 安全：指针始终指向有效的 Box<Vec<_>>
        Arc::clone(unsafe { &*raw })
    }

    fn update_skills(&self, new_skills: Vec<SkillConfig>) {
        let boxed = Box::new(Arc::new(new_skills));
        let raw = Box::into_raw(boxed);
        // Release 保证之前的写操作对后续读者可见
        let old = self.ptr.swap(raw, Ordering::Release);
        // TODO: 需要安全的内存回收（如 crossbeam::epoch）
    }
}

class Player:
    def __init__(self):
        self.hp = 100
        self.mp = 50
        self.buffs = []
    def take_damage(self, amount):
        for buff in self.buffs:
            amount = buff.on_damage(amount)
        self.hp -= amount

use specs::{World, Builder, System, ReadStorage, WriteStorage};

struct Hp(i32);
struct Mp(i32);
struct Buffs(Vec<Buff>);

struct DamageSystem;
impl<'a> System<'a> for DamageSystem {
    type SystemData = (WriteStorage<'a, Hp>, ReadStorage<'a, Buffs>);

    fn run(&mut self, (mut hps, buffs): Self::SystemData) {
        // 系统内部批量处理，缓存友好
        for (hp, buff_list) in (&mut hps, &buffs).join() {
            let mut damage = calculate_damage(); // 每帧的伤害输入
            for buff in &buff_list.0 {
                damage = buff.modify_damage(damage);
            }
            hp.0 -= damage;
        }
    }
}

use tokio::net::{TcpListener, TcpStream};
use tokio::sync::mpsc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("0.0.0.0:8080").await?;
    let (tx, mut rx) = mpsc::channel::<GameMessage>(10000);

    // 接受连接循环
    loop {
        let (socket, addr) = listener.accept().await?;
        let tx = tx.clone();
        tokio::spawn(handle_client(socket, addr, tx));
    }
}

async fn handle_client(
    mut socket: TcpStream,
    addr: std::net::SocketAddr,
    tx: mpsc::Sender<GameMessage>,
) {
    let mut buf = [0u8; 1024];
    loop {
        match socket.read(&mut buf).await {
            Ok(0) => break, // 连接关闭
            Ok(n) => {
                let msg = parse_packet(&buf[..n]);
                tx.send(GameMessage { addr, data: msg }).await.unwrap();
            }
            Err(e) => {
                eprintln!("read error from {}: {}", addr, e);
                break;
            }
        }
    }
}