Multithreading 然后在线程中执行的传入函数的生存期

我正在尝试构建一个简单的类似于管道的功能，它执行管道的每个阶段是独立的线程，并通过通道传递将它们粘在一起

Pipe::source(buffer)
     .pipe(|input, output| {...})
     .pipe(|input, output| {...})
     .sink(writer)

我一辈子都搞不清楚

pipe（）

函数的函数签名。这是我的密码：

use std::sync::mpsc::channel;
use std::io::{ChanReader,ChanWriter};
use std::thread::Thread;

struct Pipe {
    incoming: ChanReader
}

impl Pipe {
    fn source(source: &mut Buffer) -> Pipe {
        let (tx, rx) = channel();
        let reader = ChanReader::new(rx);
        let mut writer = ChanWriter::new(tx);

        loop {
            match source.read_char() {
                Ok(c) => writer.write_char(c),
                Err(_) => break
            };
        };

        Pipe { incoming: reader }
    }

    fn sink(&mut self, sink: &mut Writer) {
        loop {
            match self.incoming.read_char() {
                Ok(c) => sink.write_char(c),
                Err(_) => break
            };
        };
    }

    fn pipe(&self, transform: Box<Fn(&mut ChanReader, &mut ChanWriter)+Send>) -> Pipe {
        let (tx, rx) = channel();
        let reader = ChanReader::new(rx);
        let mut writer = ChanWriter::new(tx);

        Thread::spawn(move || {
            transform(&self.incoming, &writer);
        });

        Pipe { incoming: reader }
    }
}

使用std:：sync:：mpsc:：channel；
使用std:：io:：{ChanReader，ChanWriter}；
使用std:：thread:：thread；
结构管{
传入：ChanReader
}
注入管{
fn源（源：&mut缓冲区）->管道{
let（tx，rx）=信道（）；
let reader=ChanReader:：new（rx）；
让mut writer=ChanWriter:：new（tx）；
环路{
匹配source.read_char（）{
Ok（c）=>writer.write_char（c），
错误（）=>中断
};
};
管道{传入：读取器}
}
fn接收器（&mut self，接收器：&mut Writer）{
环路{
匹配self.incoming.read_char（）{
Ok（c）=>sink.write_char（c），
错误（）=>中断
};
};
}
fn管道（自身，变换：框）->管道{
let（tx，rx）=信道（）；
let reader=ChanReader:：new（rx）；
让mut writer=ChanWriter:：new（tx）；
线程：：生成（移动| |{
转换（&self.incoming，&writer）；
});
管道{传入：读取器}
}
}

和编译器错误：

src/lib.rs:39:28: 41:10 error: cannot infer an appropriate lifetime due to conflicting requirements
src/lib.rs:39         Thread::spawn(move || {
src/lib.rs:40             transform(&self.incoming, &writer);
src/lib.rs:41         });
src/lib.rs:39:9: 39:22 note: first, the lifetime cannot outlive the expression at 39:8...
src/lib.rs:39         Thread::spawn(move || {
                      ^~~~~~~~~~~~~
src/lib.rs:39:9: 39:22 note: ...so that the declared lifetime parameter bounds are satisfied
src/lib.rs:39         Thread::spawn(move || {
                      ^~~~~~~~~~~~~
src/lib.rs:39:9: 41:11 note: but, the lifetime must be valid for the call at 39:8...
src/lib.rs:39         Thread::spawn(move || {
src/lib.rs:40             transform(&self.incoming, &writer);
src/lib.rs:41         });
src/lib.rs:39:28: 41:10 note: ...so that argument is valid for the call
src/lib.rs:39         Thread::spawn(move || {
src/lib.rs:40             transform(&self.incoming, &writer);
src/lib.rs:41         });
src/lib.rs:39:9: 39:22 error: declared lifetime bound not satisfied
src/lib.rs:39         Thread::spawn(move || {
                      ^~~~~~~~~~~~~
src/lib.rs:34:87: 44:6 note: lifetime parameter instantiated with the anonymous lifetime #1 defined on the block at 34:86
src/lib.rs:34     fn pipe(&self, transform: Box<Fn(&mut ChanReader, &mut ChanWriter)+Send>) -> Pipe {
src/lib.rs:35         let (tx, rx) = channel();
src/lib.rs:36         let reader = ChanReader::new(rx);
src/lib.rs:37         let mut writer = ChanWriter::new(tx);
src/lib.rs:38
src/lib.rs:39         Thread::spawn(move || {
              ...
note: but lifetime parameter must outlive the static lifetime
error: aborting due to 2 previous errors
Could not compile `pipes`.

src/lib.rs:39:28:41:10错误：由于需求冲突，无法推断适当的生存期
src/lib.rs:39 Thread:：spawn（move | |{
src/lib.rs:40转换（&self.incoming，&writer）；
src/lib.rs:41}）；
src/lib.rs:39:9:39:22注意：首先，生命周期不能超过表达式在39:8的寿命。。。
src/lib.rs:39 Thread:：spawn（move | |{
^~~~~~~~~~~~~
src/lib.rs:39:9:39:22注意：…以便满足声明的生存期参数界限
src/lib.rs:39 Thread:：spawn（move | |{
^~~~~~~~~~~~~
src/lib.rs:39:9:41:11注意：但是，生存期必须对39:8的调用有效。。。
src/lib.rs:39 Thread:：spawn（move | |{
src/lib.rs:40转换（&self.incoming，&writer）；
src/lib.rs:41}）；
src/lib.rs:39:28:41:10注意：…因此该参数对调用有效
src/lib.rs:39 Thread:：spawn（move | |{
src/lib.rs:40转换（&self.incoming，&writer）；
src/lib.rs:41}）；
src/lib.rs:39:9:39:22错误：声明的生存期界限未满足
src/lib.rs:39 Thread:：spawn（move | |{
^~~~~~~~~~~~~
src/lib.rs:34:87:44:6注意：使用在34:86块上定义的匿名生存期#1实例化生存期参数
src/lib.rs:34 fn管道（&self，transform:Box）->pipe{
src/lib.rs:35 let（tx，rx）=信道（）；
src/lib.rs:36 let reader=ChanReader:：new（rx）；
src/lib.rs:37让mut writer=ChanWriter:：new（tx）；
src/lib.rs:38
src/lib.rs:39 Thread:：spawn（move | |{
...
注意：但寿命参数必须超过静态寿命
错误：由于之前的两个错误而中止
无法编译“管道”。

---

我正在使用

1.0.0-dev

Thread:：spawn

要求赋予它的函数是

'static

；因此闭包必须消耗进入它的所有东西。你已经开始引用

self.incoming

-一个非静态引用。这不起作用；你必须将读取器移入其中。wa要做到这一点，可能需要在方法

pipe

中使用

self

，而不是参考：

fn pipe<F: FnOnce(&mut ChanReader, &mut ChanWriter) + Send>(mut self, transform: F) -> Pipe {
    let (tx, rx) = channel();
    let reader = ChanReader::new(rx);
    let mut writer = ChanWriter::new(tx);

    Thread::spawn(move || {
        transform(&mut self.incoming, &mut writer);
    });

    Pipe { incoming: reader }
}

fn管道（mut-self，transform:F）->pipe{
let（tx，rx）=信道（）；
let reader=ChanReader:：new（rx）；
让mut writer=ChanWriter:：new（tx）；
线程：：生成（移动| |{
转换（&mut self.incoming，&mut writer）；
});
管道{传入：读取器}
}

现在，

self

和

writer

被移动到生成的线程中，一切都很好

---

（出于良好的考虑，我解开了你的闭包，因为没有理由将其装箱，并将其更改为

FnOnce

，以获得最大的表现力。）

太棒了。这让编译器很高兴。

框是我最后一次尝试说“给我所有的所有权，当当”。看起来
mut
指令是我在参数中缺少的