SYNC is not implemented for ThreadPool about rust-threadpool HOT 5 OPEN

Hi

Sorry this reply is so late. The reason we can not implement Sync is that the underlying channel does not implement it.
I solved the problem with a Mutex: https://play.rust-lang.org/?gist=cfd1222f7ba84f66d6338c7179a92656
If you use a local copy as in fn b then you don't loose too much speed from the mutex.
I will continue to think about that problem and hope to come up with a better solution.
If you already solved the problem, please let me know how you did it.

Cheers,
Stefan

from rust-threadpool.

We should probably just put a Mutex around the Sender inside ThreadPool. Or use crossbeam-channel.

from rust-threadpool.

One requirement currently is that this crate compiles with rust 1.9.

from rust-threadpool.

Just as a small bump, I'm also in a situation where a Sync threadpool would be useful. The execute method takes &self, so purely from an ownership point of view sharing it with an Arc (e.g. across multiple web request handlers) would be sufficient. However, this doesn't work because internally the ThreadPool isn't Sync.

from rust-threadpool.

As a workaround, if it's fine to lock/unlock the mutex for every .execute() call, a wrapper like this can be used:

use std::sync::{Arc, Mutex};

use threadpool::ThreadPool;

/// A Send + Sync thread pool.
#[derive(Debug, Clone)]
pub struct SyncThreadPool {
    pool: Arc<Mutex<ThreadPool>>,
}

impl SyncThreadPool {
    /// Create a new thread pool with the specified size.
    pub fn new(num_threads: usize) -> Self {
        Self {
            pool: Arc::new(Mutex::new(ThreadPool::new(num_threads))),
        }
    }

    /// Execute a job on the thread pool.
    pub fn execute(&self, job: impl FnOnce() + Send + 'static) {
        self.pool
            .lock()
            .expect("could not lock thread pool mutex")
            .execute(job)
    }
}

This should have the same performance characteristics as if a mutex were used internally.

from rust-threadpool.