multithreading - 在线程中使用特征方法

Question

基本上，我正在制作一个程序，它正在监听一堆端口并以不同的方式处理传入的数据包。我决定将这段代码捆绑到一个特征中:

use std::old_io::{TcpStream, TcpListener, Listener, Acceptor, EndOfFile, IoResult};
use std::thread::Thread;

trait Server {
    fn new(port: u16) -> Self;

    fn hostname(&self) -> &String;

    fn initialize(&self) {
        let acceptor = TcpListener::bind(self.hostname().as_slice()).listen().unwrap();
        Thread::spawn(move|| {
            let mut acceptor = acceptor;
            for incoming_stream in acceptor.incoming() {
                match incoming_stream {
                    Ok(stream) => {
                        self.handle_client(stream);
                    },
                    Err(ref e) if e.kind == EndOfFile => break,
                    Err(e) => panic!("Unexpected error: {}", e),
                }
            }
        });
    }

    fn handle_client(&self, stream: TcpStream) -> ();
}

pub struct InternodeServer {
    hostname: String,
}

impl Server for InternodeServer {
    fn new(port: u16) -> InternodeServer {
        let hostname = format!("127.0.0.1:{}", port);
        InternodeServer {
            hostname: hostname,
        }
    }

    fn hostname(&self) -> &String {
        &self.hostname
    }

    fn handle_client(&self, stream: TcpStream) {
        println!("Received connection");
        let mut stream = stream;
        let response = b"Hello\r\n";
        let _ = stream.write_all(response);
        let _ = stream.close_write();
    }
}

fn main() {
    let test_server = <InternodeServer as Server>::new(9337);
    test_server.initialize();
}

但是，此代码将不起作用，因为您无法发送 Self。这是我收到的错误:

test.rs:11:9: 11:22 error: the trait `core::marker::Send` is not implemented for the type `Self` [E0277]
test.rs:11         Thread::spawn(move|| {
                   ^~~~~~~~~~~~~
test.rs:11:9: 11:22 note: `Self` cannot be sent between threads safely
test.rs:11         Thread::spawn(move|| {
                   ^~~~~~~~~~~~~

所以我也尝试将 handle_client 设为静态方法来避免 self.为此，我只是将 handle_client 更改为:

fn handle_client(stream: TcpStream)

并通过以下方式引用它:

Server::handle_client(stream);

但是，我无法从服务器的初始化方法中引用 InternodeServer 的静态方法。编译时，出现如下错误:

test.rs:16:25: 16:46 error: type annotations required: cannot resolve `_ : Server` [E0283]
test.rs:16                         Server::handle_client(stream);
                                   ^~~~~~~~~~~~~~~~~~~~~
test.rs:16:25: 16:46 note: required by `Server::handle_client`
test.rs:16                         Server::handle_client(stream);

有什么办法解决这个问题吗？

Answer 1

下面是错误的较小再现:

use std::thread::Thread;

trait Server {
    fn initialize(&self) {
        Thread::spawn(move || self.handle_client());
    }

    fn handle_client(&self);
}

fn main() {}

问题是传递给 Thread::spawn 的参数必须是 Send .您正在尝试将 self 移动到闭包中，但您的特征不能保证 Send，因此闭包不能是 Send。

我们可以尝试使用 trait Server: Send 沿着这条路走下去，但是我们会得到“无法推断适当的生命周期”错误，因为 Send 也需要 '静态 ( for now )。此外，让自己进入闭包似乎很奇怪。

真的，我想你想拆分你的代码。将 handle_client 移动到一个单独的特征中，然后确保该特征的实现是 Send:

use std::thread::Thread;

trait Server {
    fn initialize<D>(&self, driver: D)
        where D: Driver + Send
    {
        Thread::spawn(move || driver.handle_client());
    }
}

trait Driver {
    fn handle_client(&self);
}

fn main() {}