Why Deadlock if put sending Terminate message and thread.join() in one loop?
In book of The Rust Programming Language 20.3 Graceful Shutdown and Cleanup https://doc.rust-lang.org/book/ch20-03-graceful-shutdown-and-cleanup.html
Here is the output for below code that could cause deadlock.
Running
target\debug\main.exeWorker 0 got a job; running.
Shutting down. Sending terminate message to all workers. Shutting down all workers.
Shutting down worker 0
Worker 1 got a job; running.
Worker 1 was told to terminate.
error: process didn't exit successfully:
target\debug\main.exe(exit code: 0xc000013a, STATUS_CONTROL_C_EXIT) ^C
for worker in &mut self.workers {
self.sender.send(Message::Terminate).unwrap();
println!("Shutting down worker {}", worker.id);
if let Some(thread) = worker.thread.take() {
thread.join().unwrap();
}
}
Could you help me understand why this coding logic could cause a Deadlock?
""" To better understand why we need two separate loops, imagine a scenario with two workers. If we used a single loop to iterate through each worker, on the first iteration a terminate message would be sent down the channel and join called on the first worker’s thread. If that first worker was busy processing a request at that moment, the second worker would pick up the terminate message from the channel and shut down. We would be left waiting on the first worker to shut down, but it never would because the second thread picked up the terminate message. Deadlock! """
I was thinking, after first worker finish task, the first worker will get next terminate message, and then break the loop.
Will thread.join() prevent first worker from accepting new message from channel? It seems not.
Here is my understanding of the logic and steps:
on the first iteration a terminate message would be sent down the channel,
first worker was busy processing a request at that moment. 2nd worker get a terminate message, and exit the loop. first worker thread.join() to main. - first worker thread is moved out of ThreadPool, by worker.thread.take(), leave the worker.thread as Option::None;
Now there is no worker.thread in ThreadPool::drop.
on the second iteration, fn ThreadPool::drop() send another terminate message down the channel,
there is no worker.thread to process the message, 2nd worker already exited the loop. then, maybe 2nd worker thread.join() to main().
At the end, the moved first worker thread is in infinite loop. main() is waiting for the thread to end, waiting for ever.
But. there is another thought, even the moved first worker thread is not in ThreadPool, the thread still has the receiver, to receive the terminate message, and then break the loop.
I'm still confusing. ^_^
