Is it normal for Tokio to open this many threads/processes? - asynchronous

Question

Is it normal for Tokio to open this many threads?
top - 19:50:25 up 5:55, 2 users, load average: 0.00, 0.00, 0.00
Threads: 9 total, 0 running, 9 sleeping, 0 stopped, 0 zombie
%Cpu(s): 0.0 us, 0.0 sy, 0.0 ni,100.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
MiB Mem : 19963.7 total, 19046.5 free, 268.3 used, 648.9 buff/cache
MiB Swap: 0.0 total, 0.0 free, 0.0 used. 19449.8 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1665 root 20 0 17556 4 0 S 0.0 0.0 0:00.00 nfwd
1666 root 20 0 17556 4 0 S 0.0 0.0 0:00.00 tokio-runtime-w
1667 root 20 0 17556 4 0 S 0.0 0.0 0:00.00 tokio-runtime-w
1668 root 20 0 17556 4 0 S 0.0 0.0 0:00.00 tokio-runtime-w
1669 root 20 0 17556 4 0 S 0.0 0.0 0:00.00 tokio-runtime-w
1670 root 20 0 17556 4 0 S 0.0 0.0 0:00.00 tokio-runtime-w
1671 root 20 0 17556 4 0 S 0.0 0.0 0:00.00 tokio-runtime-w
1672 root 20 0 17556 4 0 S 0.0 0.0 0:00.00 tokio-runtime-w
1673 root 20 0 17556 4 0 S 0.0 0.0 0:00.00 tokio-runtime-w
All I'm doing is using the tokio::net::UnixListener to listen on a socket. But as you can see in top Tokio has opened 8 different processes/threads named tokio-runtime-w.
What is causing this, it is necessary to have this many and can it be limited/omited?
pub struct StreamServer {
pub socket: UnixListener,
}
impl StreamServer {
pub async fn new() -> Result<Self, Box<dyn Error>> {
let directory = temp_dir();
let path = directory.as_path().join("d");
if path.exists() {
remove_file(&path).await?;
}
let socket = UnixListener::bind(&path)?;
Ok(Self { socket })
}
pub async fn run(&mut self) -> Result<(), Box<dyn Error>> {
loop {
match &self.socket.accept().await {
Ok((stream, addr)) => loop {
match &self.stream.readable().await {
Ok(()) => {
let mut buf = Vec::with_capacity(1024);
match &self.stream.try_read_buf(&mut buf) {
Ok(n) => {
let msg = String::from_utf8((&buf.as_slice()[..*n]).to_vec())?;
Ok((msg, *n))
}
Err(ref e) if e.kind() == ErrorKind::WouldBlock => {
Ok(("".to_string(), 0))
}
Err(e) => todo!("{:?}", e),
}
}
Err(e) => todo!("{:?}", e),
}
},
Err(ref e) if e.kind() == ErrorKind::WouldBlock => {
continue;
}
Err(_) => todo!(),
};
}
}
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
let mut stream = StreamServer::new().await?;
stream.run().await?;
}

Answer 1

Yes, this looks like a normal result.
There are a fixed number of worker_threads:
The default value is the number of cores available to the system.
And a dynamic number of blocking_threads:
The default value is 512.
You can configure the Runtime using the methods linked above, or worker_threads is configurable in the attribute like so:
#[tokio::main(worker_threads = 2)]