在workerpool::thunk中提供了一个工作线程，它是一个无状态的ThunkWorker<T>。它接受Thunk<T>类型的输入，实际上是无参数函数，它们是Sized + Send。这些thunks是通过使用Thunk::of包装返回类型为T的函数来创建的。

use workerpool::Pool;
use workerpool::thunk::{Thunk, ThunkWorker};
use std::sync::mpsc::channel;

fn main() {
    let n_workers = 4;
    let n_jobs = 8;
    let pool = Pool::<ThunkWorker<i32>>::new(n_workers);
    
    let (tx, rx) = channel();
    for i in 0..n_jobs {
        pool.execute_to(tx.clone(), Thunk::of(move || i * i));
    }
    
    assert_eq!(140, rx.iter().take(n_jobs as usize).sum());
}

对于有状态的线程池，您需要自己实现Worker。

假设有一个按行分隔的进程，如cat或tr，您希望它在多个线程上运行，以便像线程池一样使用。您可以使用以下方式创建并使用一个工作线程，以维护进程的stdin/stdout状态：

use workerpool::{Worker, Pool};
use std::process::{Command, ChildStdin, ChildStdout, Stdio};
use std::io::prelude::*;
use std::io::{self, BufReader};
use std::sync::mpsc::channel;

struct LineDelimitedProcess {
    stdin: ChildStdin,
    stdout: BufReader<ChildStdout>,
}
impl Default for LineDelimitedProcess {
    fn default() -> Self {
        let child = Command::new("cat")
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::inherit())
            .spawn()
            .unwrap();
        Self {
            stdin: child.stdin.unwrap(),
            stdout: BufReader::new(child.stdout.unwrap()),
        }
    }
}
impl Worker for LineDelimitedProcess {
    type Input = Box<[u8]>;
    type Output = io::Result<String>;

    fn execute(&mut self, inp: Self::Input) -> Self::Output {
        self.stdin.write_all(&*inp)?;
        self.stdin.write_all(b"\n")?;
        self.stdin.flush()?;
        let mut s = String::new();
        self.stdout.read_line(&mut s)?;
        s.pop(); // exclude newline
        Ok(s)
    }
}

fn main() {
    let n_workers = 4;
    let n_jobs = 8;
    let pool = Pool::<LineDelimitedProcess>::new(n_workers);
    
    let (tx, rx) = channel();
    for i in 0..n_jobs {
        let inp = Box::new([97 + i]);
        pool.execute_to(tx.clone(), inp);
    }
    
    // output is a permutation of "abcdefgh"
    let mut output = rx.iter()
        .take(n_jobs as usize)
        .fold(String::new(), |mut a, b| {
            a.push_str(&b.unwrap());
            a
        })
        .into_bytes();
    output.sort();
    assert_eq!(output, b"abcdefgh");
}

类似库

• threadpool
• rust-scoped-pool
• scoped-threadpool-rs
• crossbeam

许可证

本作品是threadpool的衍生作品。

根据您的选择，许可如下：

• Apache License, Version 2.0, (LICENSE-APACHE或https://apache.ac.cn/licenses/LICENSE-2.0)
• MIT license (LICENSE-MIT或http://opensource.org/licenses/MIT)

。

贡献

除非您明确声明，否则根据Apache-2.0许可证定义，您有意提交的任何贡献，旨在包含在作品中，应如上所述双许可，不附加任何额外条款或条件。