Rust 从一个线程引用 TCPListener 和 TcpStream 到另一个线程中的 Struct

我不知道您是从哪里得到使用channel将对象发送到您刚刚产生的线程的 idea 的，但在这种情况下它肯定是不正确的.

只需使用move ||闭包来将外部变量移入其中即可.

考虑到这一点，下面的代码编译如下:(尽管我无法测试它是否工作)

use std::io::Read;
use std::net::{TcpListener, TcpStream};
use std::sync::{mpsc, Arc, Mutex};
use std::thread;

fn main() {
    let server = Server::start("127.0.0.1:25565".to_string());
    loop {
        for client in &server.connected_clients {
            println!("{:?}", client.stream.peer_addr().unwrap())
        }
    }
}

#[derive(Debug)]
struct Server {
    listener: Arc<Mutex<TcpListener>>,
    connected_clients: Vec<Client>,
}

impl Server {
    pub fn start(address: String) -> Server {
        let server = Server {
            listener: Arc::new(Mutex::new(TcpListener::bind(address).unwrap())),
            connected_clients: Vec::new(),
        };

        let listener = server.listener.clone();
        thread::spawn(move || {
            // For each new connection start a new thread
            for stream in listener.lock().unwrap().incoming() {
                let mut stream = stream.unwrap();
                thread::spawn(move || {
                    // TODO: Add client to the connected_clients Vec
                    let mut buffer = [0; 1024];
                    loop {
                        stream.read(&mut buffer).unwrap();
                        println!(
                            "{}",
                            String::from_utf8(Vec::from(&buffer[..]))
                                .unwrap()
                                .trim_end_matches(char::from(0))
                        );
                    }
                });
            }
        });

        server
    }
}

#[derive(Debug)]
struct Client {
    id: usize,
    stream: TcpStream,
}

从技术上讲，虽然在这种情况下完全是过度杀伤力，但您的channel方法也可以工作，但然后您必须发送对象的实际实例，而不是引用.并且您仍然需要使用move ||闭包来将rx对象移到其中.

use std::io::Read;
use std::net::{TcpListener, TcpStream};
use std::sync::{mpsc, Arc, Mutex};
use std::thread;

fn main() {
    let server = Server::start("127.0.0.1:25565".to_string());
    loop {
        for client in &server.connected_clients {
            println!("{:?}", client.stream.peer_addr().unwrap())
        }
    }
}

#[derive(Debug)]
struct Server {
    listener: Arc<Mutex<TcpListener>>,
    connected_clients: Vec<Client>,
}

impl Server {
    pub fn start(address: String) -> Server {
        let listener = TcpListener::bind(address).unwrap();

        let (tx, rx) = mpsc::channel();
        let listener = Arc::new(Mutex::new(listener));

        let server = Server {
            listener: listener,
            connected_clients: Vec::new(),
        };

        tx.send(server.listener.clone()).unwrap();

        thread::spawn(move || {
            let listener = rx.recv().unwrap();
            // For each new connection start a new thread
            for stream in listener.lock().unwrap().incoming() {
                let mut stream = stream.unwrap();
                thread::spawn(move || {
                    // TODO: Add client to the connected_clients Vec
                    let mut buffer = [0; 1024];
                    loop {
                        stream.read(&mut buffer).unwrap();
                        println!(
                            "{}",
                            String::from_utf8(Vec::from(&buffer[..]))
                                .unwrap()
                                .trim_end_matches(char::from(0))
                        );
                    }
                });
            }
        });

        server
    }
}

#[derive(Debug)]
struct Client {
    id: usize,
    stream: TcpStream,
}

最后一句话:

不过，我对整个 struct 的实用性提出了质疑.一旦您的线程进入for循环，您的listener就会被连续锁定，这意味着任何试图通过您的Server对象实际访问它的人都将死锁.