jtp 0.1.0

A simple implementation of a thread pool.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use std::{
    thread::{self, JoinHandle},
    time::Duration,
};

use crossbeam_channel::Receiver;

use crate::task::Task;

/// A worker holds a thread and a receiver.
pub struct Worker {
    pub(crate) is_core: bool,
    receiver: Receiver<Task>,
    keep_alive_time: Duration,
    thread: JoinHandle<()>,
}

fn create_core_work_thread(receiver: Receiver<Task>, task: Task) -> JoinHandle<()> {
    thread::spawn(move || {
        task.run();
        while let Ok(task) = receiver.recv() {
            task.run();
        }
    })
}

fn create_work_thread(
    receiver: Receiver<Task>,
    task: Task,
    keep_alive_time: Duration,
) -> JoinHandle<()> {
    thread::spawn(move || {
        task.run();
        while let Ok(task) = receiver.recv_timeout(keep_alive_time) {
            task.run();
        }
    })
}

impl Worker {
    #[must_use]
    pub fn new(
        is_core: bool,
        keep_alive_time: Duration,
        receiver: Receiver<Task>,
        task: Task,
    ) -> Self {
        Worker {
            is_core,
            keep_alive_time,
            receiver: receiver.clone(),
            thread: if is_core {
                create_core_work_thread(receiver, task)
            } else {
                create_work_thread(receiver, task, keep_alive_time)
            },
        }
    }

    /// If the `self` worker is idle and is not core, creates a new
    /// thread for the worker to process the given task.
    ///
    /// This will make the `self` worker available again.
    pub(crate) fn restart(&mut self, task: Task) {
        debug_assert!(self.is_finished() && !self.is_core);
        self.thread = create_work_thread(self.receiver.clone(), task, self.keep_alive_time);
    }

    #[inline]
    pub fn is_finished(&self) -> bool {
        self.thread.is_finished()
    }

    #[inline]
    pub(crate) fn join(self) -> thread::Result<()> {
        self.thread.join()
    }
}