mirror of
https://github.com/tokio-rs/tokio.git
synced 2026-08-21 00:00:10 +02:00
Jon Gjengset
03a9378297
Previously, support for `blocking` was done through a static `POOL` that would spawn threads on demand. While this made the pool accessible at all times, it made it hard to configure, and it was impossible to keep multiple blocking pools. This patch changes `blocking` to instead use a "default" global like the ones used for timers, executors, and the like. There is now `blocking::with_pool`, which is used by both thread-pool workers and the current-thread runtime to ensure that a pool is available to tasks. This patch also changes `ThreadPool` to spawn its worker threads on the blocking pool rather than as free-standing threads. This is in preparation for the coming in-place blocking work. One downside of this change is that thread names are no longer "semantic". All threads are named by the pool name, and individual threads are not (currently) given names with numerical suffixes like before.
58 lines
1.5 KiB
Rust
58 lines
1.5 KiB
Rust
use super::Pool;
|
|
use crate::loom::thread;
|
|
use std::usize;
|
|
|
|
/// Builds a blocking thread pool with custom configuration values.
|
|
pub(crate) struct Builder {
|
|
/// Thread name
|
|
name: String,
|
|
|
|
/// Thread stack size
|
|
stack_size: Option<usize>,
|
|
}
|
|
|
|
impl Default for Builder {
|
|
fn default() -> Self {
|
|
Builder {
|
|
name: "tokio-blocking-thread".to_string(),
|
|
stack_size: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Builder {
|
|
/// Set name of threads spawned by the pool
|
|
///
|
|
/// If this configuration is not set, then the thread will use the system
|
|
/// default naming scheme.
|
|
pub(crate) fn name<S: Into<String>>(&mut self, val: S) -> &mut Self {
|
|
self.name = val.into();
|
|
self
|
|
}
|
|
|
|
/// Set the stack size (in bytes) for worker threads.
|
|
///
|
|
/// The actual stack size may be greater than this value if the platform
|
|
/// specifies minimal stack size.
|
|
///
|
|
/// The default stack size for spawned threads is 2 MiB, though this
|
|
/// particular stack size is subject to change in the future.
|
|
pub(crate) fn stack_size(&mut self, val: usize) -> &mut Self {
|
|
self.stack_size = Some(val);
|
|
self
|
|
}
|
|
|
|
pub(crate) fn build(self) -> Pool {
|
|
let mut p = Pool::default();
|
|
let Builder { stack_size, name } = self;
|
|
p.new_thread = Box::new(move || {
|
|
let mut b = thread::Builder::new().name(name.clone());
|
|
if let Some(stack_size) = stack_size {
|
|
b = b.stack_size(stack_size);
|
|
}
|
|
b
|
|
});
|
|
p
|
|
}
|
|
}
|