Rust 东京回声服务器。不能在同一将来读写

我正试图在东京建立一个回声服务器。我看过一些例子，但它们似乎都使用了Tokio io的

io:：copy

，我不能使用，因为我想修改输出

但是，我无法编译同时使用

writer

和

reader

的服务器。我想构建一个基于未来的任务，它支持在循环中读/写（echo服务器）

我的实际代码是：

extern crate futures;
extern crate futures_cpupool;
extern crate tokio;
extern crate tokio_io;

use futures::prelude::*;
use futures_cpupool::CpuPool;
use tokio_io::AsyncRead;
use futures::Stream;
use futures::stream;
use tokio_io::codec::*;
use std::rc::Rc;

fn main() {
    let pool = CpuPool::new_num_cpus();
    use std::net::*;
    let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
    let listener = tokio::net::TcpListener::bind(&socket).unwrap();
    let server = listener.incoming().for_each(|socket| {
        let (writer, reader) = socket.framed(LinesCodec::new()).split();
        let writer = Rc::new(writer);
        let action = reader.for_each(|line| {
            println!("ECHO: {}", line);
            writer.send(line);
            Ok(())
        });
        pool.spawn(action); // std::rc::Rc<futures::stream::SplitSink<tokio_io::codec::Framed<tokio::net::TcpStream, tokio_io::codec::LinesCodec>>>` cannot be shared between threads safely
        Ok(())
    });
    server.wait().unwrap();
}

---

它说的错误是：

无法移出借用的内容

我终于发现

转发

是我问题的答案

extern crate tokio;
extern crate tokio_io;
extern crate futures;

use futures::prelude::*;
use tokio_io::AsyncRead;
use futures::Stream;
use tokio_io::codec::*;


struct Cancellable{
    rx: std::sync::mpsc::Receiver<()>,
}

impl Future for Cancellable {
    type Item = ();
    type Error = std::sync::mpsc::RecvError;

    fn poll(&mut self) -> Result<Async<Self::Item>,Self::Error> {
        match self.rx.try_recv() {
            Ok(_) => Ok(Async::Ready(())),
            Err(_) => Ok(Async::NotReady)
        }
    }
}

fn main() {
    use std::net::*;
    let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
    let listener = tokio::net::TcpListener::bind(&socket).unwrap();
    let server = listener.incoming().for_each(|socket|{
        let (writer,reader) = socket.framed(LinesCodec::new()).split();
        let (tx,rx) = std::sync::mpsc::channel();
        let cancel = Cancellable {
            rx: rx,
        };
        let action = reader
        .map(move |line|{
            println!("ECHO: {}",line);
            if line == "bye"{
                println!("BYE");
                tx.send(()).unwrap();
            }
            line
        })
        .forward(writer)
        .select2(cancel)
        .map(|_|{

        })
        .map_err(|err|{
            println!("error");
        });
        tokio::executor::current_thread::spawn(action);

        Ok(())
    }).map_err(|err|{
        println!("error = {:?}",err);
    });
    tokio::executor::current_thread::run(|_|{
        tokio::executor::current_thread::spawn(server);
    });
}

extern板条箱东京；
外部板条箱东京；
外部板条箱期货；
使用期货：：前奏：：*；
使用tokio_io:：AsyncRead；
使用流；
使用tokio_io:：编解码器：：*；
结构可取消{
接收：标准：：同步：：mpsc：：接收机，
}
可取消的impl未来{
类型项=（）；
类型错误=std:：sync:：mpsc:：RecvError；
fn轮询（&mut self）->结果{
匹配self.rx.try_recv（）{
Ok（）=>Ok（异步：：就绪（（）），
Err（）=>Ok（异步：：NotReady）
}
}
}
fn main（）{
使用std:：net:：*；
让socket=SocketAddr:：new（IpAddr:：V4（Ipv4Addr:：new（127,0,0,1）），8080）；
让listener=tokio:：net:：TcpListener:：bind（&socket）.unwrap（）；
对于每个（|套接字），让server=listener.incoming（）|{
let（writer，reader）=socket.framed（LinesCodec:：new（））.split（）；
let（tx，rx）=std:：sync:：mpsc:：channel（）；
让取消=可取消{
rx:rx，
};
让行动=读取器
.地图（移动|线|{
println！（“ECHO:{}”，行）；
如果行==“再见”{
println！（“再见”）；
tx.send（（））.unwrap（）；
}
线
})
.转发（作者）
。选择2（取消）
.地图(|_|{
})
.map_err（| err|{
println！（“错误”）；
});
tokio:：executor:：current_thread:：spawn（操作）；
好（（））
}).map_err（| err|{
println！（“error={：？}”，err）；
});
tokio:：executor:：当前线程：：运行(|_|{
tokio:：executor:：current_thread:：spawn（服务器）；
});
}

我很确定编译器不会只输出“错误”。请包含完整的错误消息。错误代码：std:：rc:：rc`无法在线程之间安全共享。但是，使用Arc无法解决问题：writer.send（line）；-^^^无法移出借用的内容。请编辑您的问题并添加错误消息和其他信息。在注释中不要这样做。我正在尝试构建一个echo服务器[…]我想修改输出-修改输入似乎与echo服务器的功能完全相反。

extern crate tokio;
extern crate tokio_io;
extern crate futures;

use futures::prelude::*;
use tokio_io::AsyncRead;
use futures::Stream;
use tokio_io::codec::*;


struct Cancellable{
    rx: std::sync::mpsc::Receiver<()>,
}

impl Future for Cancellable {
    type Item = ();
    type Error = std::sync::mpsc::RecvError;

    fn poll(&mut self) -> Result<Async<Self::Item>,Self::Error> {
        match self.rx.try_recv() {
            Ok(_) => Ok(Async::Ready(())),
            Err(_) => Ok(Async::NotReady)
        }
    }
}

fn main() {
    use std::net::*;
    let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
    let listener = tokio::net::TcpListener::bind(&socket).unwrap();
    let server = listener.incoming().for_each(|socket|{
        let (writer,reader) = socket.framed(LinesCodec::new()).split();
        let (tx,rx) = std::sync::mpsc::channel();
        let cancel = Cancellable {
            rx: rx,
        };
        let action = reader
        .map(move |line|{
            println!("ECHO: {}",line);
            if line == "bye"{
                println!("BYE");
                tx.send(()).unwrap();
            }
            line
        })
        .forward(writer)
        .select2(cancel)
        .map(|_|{

        })
        .map_err(|err|{
            println!("error");
        });
        tokio::executor::current_thread::spawn(action);

        Ok(())
    }).map_err(|err|{
        println!("error = {:?}",err);
    });
    tokio::executor::current_thread::run(|_|{
        tokio::executor::current_thread::spawn(server);
    });
}