Struct WorkPool 

pub struct WorkPool<T> { /* private fields */ }

Implementations

impl<T: Clone + Send> WorkPool<T>

pub fn new( num_threads: usize, buf_len: Option<usize>, ) -> Result<WorkPool<T>, ()>

Create a new WorkPool

Examples found in repository

examples/stream.rs (line 18)

fn main() {
    let addr = SocketAddr::from(([0, 0, 0, 0], 8080));
    let listener = TcpListener::bind(addr).expect("Failed to bind to port 8080");

    // Setting the threads to 0 will let the system choose the number
    // of threads. Setting the buffer length to None will default the
    // buffer length to a reasonable amount.
    let mut pool = WorkPool::new(0, None).expect("Failed to build work pool");
    pool.set_executor_and_start(|stream| { handle(stream); });

    println!("Bound to port 8080 - Send a request!");
    println!("Press Ctrl+C to quit ...");

    for stream in listener.incoming() {
        match stream {
            Ok(s) => pool.dispatch(Arc::new(s)),
            Err(e) => eprintln!("failed to get incomign stream {:?}", e),
        }
    }
}

examples/basic.rs (line 11)

fn main() {
    // Specify the number of threads to be used and the number of work
    // item spaces to start with.
    //
    // Setting the threads to 0 will let the system choose the number
    // of threads. Setting the buffer length to None will default the
    // buffer length to a reasonable amount.
    let mut pool = WorkPool::new(0, None).expect("Failed to build work pool");

    pool.set_executor_and_start(|work| {
        println!("thread {:?} got item {}", thread::current().id(), work);
    });

    // Dispatch some work to do
    pool.dispatch(1);
    pool.dispatch(2);
    pool.dispatch(3);
    pool.dispatch(4);

    // Or, dispatch a bunch of work at once
    pool.dispatch_many(vec![5, 6, 7, 8]);

    // Closing the pool will send a quit message to the threads and
    // block while it waits for the threads to join.
    //
    // Dropping the pool will send a quit message to
    // the threads and detach them - you won't have to
    // wait for the threads to join
    pool.close();

    println!("Done");
}

pub fn dispatch(&mut self, work: T)

Send a job to the pool

Examples found in repository

examples/stream.rs (line 26)

fn main() {
    let addr = SocketAddr::from(([0, 0, 0, 0], 8080));
    let listener = TcpListener::bind(addr).expect("Failed to bind to port 8080");

    // Setting the threads to 0 will let the system choose the number
    // of threads. Setting the buffer length to None will default the
    // buffer length to a reasonable amount.
    let mut pool = WorkPool::new(0, None).expect("Failed to build work pool");
    pool.set_executor_and_start(|stream| { handle(stream); });

    println!("Bound to port 8080 - Send a request!");
    println!("Press Ctrl+C to quit ...");

    for stream in listener.incoming() {
        match stream {
            Ok(s) => pool.dispatch(Arc::new(s)),
            Err(e) => eprintln!("failed to get incomign stream {:?}", e),
        }
    }
}

examples/basic.rs (line 18)

fn main() {
    // Specify the number of threads to be used and the number of work
    // item spaces to start with.
    //
    // Setting the threads to 0 will let the system choose the number
    // of threads. Setting the buffer length to None will default the
    // buffer length to a reasonable amount.
    let mut pool = WorkPool::new(0, None).expect("Failed to build work pool");

    pool.set_executor_and_start(|work| {
        println!("thread {:?} got item {}", thread::current().id(), work);
    });

    // Dispatch some work to do
    pool.dispatch(1);
    pool.dispatch(2);
    pool.dispatch(3);
    pool.dispatch(4);

    // Or, dispatch a bunch of work at once
    pool.dispatch_many(vec![5, 6, 7, 8]);

    // Closing the pool will send a quit message to the threads and
    // block while it waits for the threads to join.
    //
    // Dropping the pool will send a quit message to
    // the threads and detach them - you won't have to
    // wait for the threads to join
    pool.close();

    println!("Done");
}

pub fn dispatch_many(&mut self, work: Vec<T>)

Send a list of jobs to the pool

Examples found in repository

examples/basic.rs (line 24)

fn main() {
    // Specify the number of threads to be used and the number of work
    // item spaces to start with.
    //
    // Setting the threads to 0 will let the system choose the number
    // of threads. Setting the buffer length to None will default the
    // buffer length to a reasonable amount.
    let mut pool = WorkPool::new(0, None).expect("Failed to build work pool");

    pool.set_executor_and_start(|work| {
        println!("thread {:?} got item {}", thread::current().id(), work);
    });

    // Dispatch some work to do
    pool.dispatch(1);
    pool.dispatch(2);
    pool.dispatch(3);
    pool.dispatch(4);

    // Or, dispatch a bunch of work at once
    pool.dispatch_many(vec![5, 6, 7, 8]);

    // Closing the pool will send a quit message to the threads and
    // block while it waits for the threads to join.
    //
    // Dropping the pool will send a quit message to
    // the threads and detach them - you won't have to
    // wait for the threads to join
    pool.close();

    println!("Done");
}

pub fn set_executor_and_start<F>(&mut self, executor: F)

where F: FnOnce(T) + Copy + Send + 'static, T: Send + 'static,

Setup the job executor function and start threads

Examples found in repository

examples/stream.rs (line 19)

fn main() {
    let addr = SocketAddr::from(([0, 0, 0, 0], 8080));
    let listener = TcpListener::bind(addr).expect("Failed to bind to port 8080");

    // Setting the threads to 0 will let the system choose the number
    // of threads. Setting the buffer length to None will default the
    // buffer length to a reasonable amount.
    let mut pool = WorkPool::new(0, None).expect("Failed to build work pool");
    pool.set_executor_and_start(|stream| { handle(stream); });

    println!("Bound to port 8080 - Send a request!");
    println!("Press Ctrl+C to quit ...");

    for stream in listener.incoming() {
        match stream {
            Ok(s) => pool.dispatch(Arc::new(s)),
            Err(e) => eprintln!("failed to get incomign stream {:?}", e),
        }
    }
}

examples/basic.rs (lines 13-15)

fn main() {
    // Specify the number of threads to be used and the number of work
    // item spaces to start with.
    //
    // Setting the threads to 0 will let the system choose the number
    // of threads. Setting the buffer length to None will default the
    // buffer length to a reasonable amount.
    let mut pool = WorkPool::new(0, None).expect("Failed to build work pool");

    pool.set_executor_and_start(|work| {
        println!("thread {:?} got item {}", thread::current().id(), work);
    });

    // Dispatch some work to do
    pool.dispatch(1);
    pool.dispatch(2);
    pool.dispatch(3);
    pool.dispatch(4);

    // Or, dispatch a bunch of work at once
    pool.dispatch_many(vec![5, 6, 7, 8]);

    // Closing the pool will send a quit message to the threads and
    // block while it waits for the threads to join.
    //
    // Dropping the pool will send a quit message to
    // the threads and detach them - you won't have to
    // wait for the threads to join
    pool.close();

    println!("Done");
}

pub fn close(&mut self)

Send a quit message to all threads and wait for them to join.

Examples found in repository

examples/basic.rs (line 32)

fn main() {
    // Specify the number of threads to be used and the number of work
    // item spaces to start with.
    //
    // Setting the threads to 0 will let the system choose the number
    // of threads. Setting the buffer length to None will default the
    // buffer length to a reasonable amount.
    let mut pool = WorkPool::new(0, None).expect("Failed to build work pool");

    pool.set_executor_and_start(|work| {
        println!("thread {:?} got item {}", thread::current().id(), work);
    });

    // Dispatch some work to do
    pool.dispatch(1);
    pool.dispatch(2);
    pool.dispatch(3);
    pool.dispatch(4);

    // Or, dispatch a bunch of work at once
    pool.dispatch_many(vec![5, 6, 7, 8]);

    // Closing the pool will send a quit message to the threads and
    // block while it waits for the threads to join.
    //
    // Dropping the pool will send a quit message to
    // the threads and detach them - you won't have to
    // wait for the threads to join
    pool.close();

    println!("Done");
}

Trait Implementations

impl<T: Debug> Debug for WorkPool<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Drop for WorkPool<T>

fn drop(&mut self)

When dropping this struct, threads will be detached