Second lock on same variable in a single expression blocks indefinitely - rust

Question

I have a Node containing a Mutex on a shared Protocol which is in turn used among different threads within a thread pool:
use std::sync::{Arc, Mutex};
pub struct Node {
thread_pool: ThreadPool,
protocol: Arc<Mutex<Protocol>>,
}
pub struct Protocol {}
impl Protocol {
pub fn is_leader(&self) -> bool {
// Do stuff...
}
pub fn is_co_leader(&self) -> bool {
// Do stuff...
}
}
When I try to acquire a lock on the protocol of the Node within the same if-statement, the code within that statement is never executed.
impl Node {
pub fn sign(&mut self) {
let protocol_handler = Arc::clone(&self.protocol);
self.thread_pool.execute(move || {
if !protocol_handler.lock().unwrap().is_leader()
&& !protocol_handler.lock().unwrap().is_co_leader()
{
// This is never executed
}
// And this neither...
})
}
}
However, if the values of the method invocations are assigned to two variables, everything works as intended:
impl Node {
pub fn sign(&mut self) {
let protocol_handler = Arc::clone(&self.protocol);
self.thread_pool.execute(move || {
let is_leader = protocol_handler.lock().unwrap().is_leader();
let is_co_leader = protocol_handler.lock().unwrap().is_co_leader();
if !is_leader && !is_co_leader {
// Either this will be executed
}
// or this ...
})
}
}
Is there any specific cause for Rust's behaviour to wait indefinitely in the first case?

Answer 1

Here is an MCVE for your problem:
use std::sync::Mutex;
fn main() {
let foo = Mutex::new(42i32);
let f1 = (*foo.lock().unwrap()).count_ones();
println!("f1: {}", f1);
let f2 = (*foo.lock().unwrap()).count_zeros();
println!("f2: {}", f2);
let tot = (*foo.lock().unwrap()).count_ones() + (*foo.lock().unwrap()).count_zeros();
println!("tot: {}", tot);
}
playground
When running this code it will print f1 and f2, then hang when trying to compute tot.
The problem is that Mutex::lock returns a MutexGuard which releases the lock automatically when it goes out of scope. In the example above, the guards go out of scope at the end of the expressions in which they are used. So when I write:
let f1 = (*foo.lock().unwrap()).count_ones();
I acquire the lock, read the value, and release the lock. Therefore the lock is free when computing f2.
However, when I write:
let tot = (*foo.lock().unwrap()).count_ones() + (*foo.lock().unwrap()).count_zeros();
I acquire the lock, read the value, try to acquire the lock again and only release both guards at the end of the line. This causes the code to deadlock when I try to acquire the lock for the second time without having released it first.
Note as commented by trentcl that your two steps example is subject to race conditions if things are changed between the two times the mutex is locked. You should rather use something like this:
impl Node {
pub fn sign(&mut self) {
let protocol_handler = Arc::clone(&self.protocol);
self.thread_pool.execute(move || {
let handler = protocol_handler.lock().unwrap();
if !handler.is_leader && !handler.is_co_leader {
// Either this will be executed
}
// or this ...
})
}
}