Rust中如何在子线程运行含无限循环的对象并保留其使用权？

你遇到的问题核心是所有权转移导致主线程无法访问已移入子线程的对象，同时需要实现主线程向运行中的ClientManager发送请求的需求。下面给出两种可行的解决方案，并解答线程使用的合理性问题。

方案一：用线程安全智能指针共享所有权 #

如果你的ClientManager需要主线程和子线程同时访问，可以用Arc<Mutex<ClientManager>>（或Arc<RwLock<ClientManager>>）来包装对象，实现线程安全的共享：

1. 包装ClientManager为线程安全的共享实例：

use std::sync::{Arc, Mutex};
use std::thread;

// 初始化event_hub和ClientManager
let event_hub = simple_websockets::launch(8080)
    .expect("failed to listen on port 8080");
let client_manager = Arc::new(Mutex::new(ClientManager::new(event_hub)));

2. 克隆Arc给子线程，避免所有权转移：

// 克隆Arc，子线程持有一份引用
let manager_clone = Arc::clone(&client_manager);
thread::spawn(move || {
    // 锁定Mutex获取可变引用，执行run循环
    if let Ok(mut manager) = manager_clone.lock() {
        manager.run();
    }
});

3. 主线程调用broadcast时，同样锁定Mutex：

// 主线程通过Arc锁定对象，调用广播方法
if let Ok(manager) = client_manager.lock() {
    manager.broadcast(String::from("hello"));
}

⚠️ 注意：如果run()方法是无限循环且持续持有锁，主线程调用lock()会被阻塞。这种情况下更推荐下面的消息通道方案。

方案二：用消息通道实现跨线程通信（更优） #

直接共享可变对象容易引发竞态条件，用std::sync::mpsc或crossbeam::channel消息通道让主线程向子线程发送指令，由子线程自身处理广播逻辑，更符合Rust的所有权安全模型：

1. 定义消息类型，封装主线程需要发送的指令：

use crossbeam::channel;

// 定义ClientManager能处理的指令类型
enum ManagerCommand {
    Broadcast(String),
    // 可扩展其他指令，比如踢除客户端、获取在线数等
}

2. 修改ClientManager，让它持有消息接收端，在run循环中同时处理WebSocket事件和指令：

use std::collections::HashMap;
use simple_websockets::ClientId;

struct ClientManager {
    event_hub: simple_websockets::EventHub,
    rx: channel::Receiver<ManagerCommand>,
    clients: HashMap<ClientId, ()>, // 示例客户端存储结构
}

impl ClientManager {
    // 新增接收端参数
    fn new(event_hub: simple_websockets::EventHub, rx: channel::Receiver<ManagerCommand>) -> Self {
        Self {
            event_hub,
            rx,
            clients: HashMap::new(),
        }
    }

    fn run(&mut self) {
        loop {
            // 同时监听WebSocket事件和消息通道
            crossbeam::select! {
                recv(self.event_hub) -> event => {
                    match event.unwrap() {
                        simple_websockets::Event::Connect(client_id, _) => {
                            self.clients.insert(client_id, ());
                        }
                        simple_websockets::Event::Disconnect(client_id) => {
                            self.clients.remove(&client_id);
                        }
                        _ => {}
                    }
                }
                recv(self.rx) -> cmd => {
                    match cmd.unwrap() {
                        ManagerCommand::Broadcast(msg) => {
                            // 执行广播逻辑
                            for &client_id in self.clients.keys() {
                                self.event_hub.send(client_id, simple_websockets::Message::Text(msg.clone()));
                            }
                        }
                    }
                }
            }
        }
    }
}

3. 主线程创建通道，启动子线程并发送指令：

// 创建消息通道
let (tx, rx) = channel::unbounded();

// 初始化ClientManager并传入接收端
let event_hub = simple_websockets::launch(8080)
    .expect("failed to listen on port 8080");
let client_manager = ClientManager::new(event_hub, rx);

// 启动子线程执行run循环
thread::spawn(move || client_manager.run());

// 主线程发送广播指令
tx.send(ManagerCommand::Broadcast(String::from("hello"))).unwrap();

关于线程使用的疑问 #

用线程来运行WebSocket事件循环是合理且常见的做法——因为事件循环是阻塞的，放在子线程中不会阻塞主线程的其他业务逻辑（比如处理HTTP请求、定时任务等）。关键是要遵循Rust的所有权和线程安全规则，避免直接转移所有权后再尝试访问，而是通过智能指针或消息通道实现安全的跨线程交互。

内容的提问来源于stack exchange，提问作者ern0