Mutex never reached under match when use from thread - rust

Question

I have a TCP client implemented with tokio. I have 3 threads there, also I have 2 Mutex<VecDeque> queues (where Mutex is tokio::sync::Mutex). The issue is that my locks processed incorrectly. When I put some println! inside match of handle_write method, I see only this println! output -> "I see output here", but no println! output from match:
async fn handle_write(&mut self) {
let stream = Arc::clone(&self.stream);
let session = Arc::clone(&self.session);
let output_queue = Arc::clone(&self.output_queue);
tokio::spawn(async move {
println!("I see output here");
match stream.lock().await.as_mut() {
Some(stream) => {
println!("Stream exists -> BUT no output");
let packet = match output_queue.lock().await.pop_front() {
Some(packet) => match session.lock().await.header_crypt.as_mut() {
Some(header_crypt) => header_crypt.encrypt(&packet),
_ => packet,
},
_ => vec![],
};
if !packet.is_empty() {
println!("My packet do not displayed: {:?}", &packet);
stream.write(&packet).await.unwrap();
stream.flush().await.unwrap();
}
},
_ => {
println!("No stream -> ALSO no output");
},
};
}).await.unwrap()
}
at the same time I see output here ("Stream exists -> and I see output !"):
async fn handle_read(&mut self) {
let queue = Arc::clone(&self.input_queue);
let stream = Arc::clone(&self.stream);
let session = Arc::clone(&self.session);
tokio::spawn(async move {
match stream.lock().await.as_mut() {
Some(stream) => {
println!("Stream exists -> and I see output !");
let mut buffer = [0u8; 4096];
match stream.read(&mut buffer).await {
Ok(bytes_count) => {
println!("{}", &bytes_count);
let raw_data = match session.lock().await.header_crypt.as_mut() {
Some(header_crypt) => header_crypt.decrypt(&buffer[..bytes_count]),
_ => buffer[..bytes_count].to_vec(),
};
queue.lock().await.push_back(raw_data);
},
_ => {},
};
},
_ => {},
};
}).await.unwrap()
}
this is how this handlers called:
pub async fn handle_connection(&mut self) {
let packet = vec![1, 2, 3, 4, 5];
self.output_queue.lock().await.push_back(packet);
loop {
timeout(Duration::from_millis(TIMEOUT), self.handle_read()).await.unwrap();
timeout(Duration::from_millis(TIMEOUT), self.handle_queue()).await.unwrap();
timeout(Duration::from_millis(TIMEOUT), self.handle_write()).await.unwrap();
}
}
this is playground (however I do not understand how to allow tcp connection there, maybe somebody can tell in comments ?).
Why this part of handle_write never reached ?
match stream.lock().await.as_mut() {
Some(stream) => {
println!("Stream exists -> do not output");
let packet = match output_queue.lock().await.pop_front() {
Some(packet) => match session.lock().await.header_crypt.as_mut() {
Some(header_crypt) => header_crypt.encrypt(&packet),
_ => packet,
},
_ => vec![],
};
if !packet.is_empty() {
println!("My packet do not displayed: {:?}", &packet);
stream.write(&packet).await.unwrap();
stream.flush().await.unwrap();
}
},
_ => {
println!("No stream -> do not output");
},
};

Answer 1

You're misusing mutexes.
The technical reason is that you have a deadlock: after the lock for self.stream in handle_read() is acquired, and when new data arrives, you try to lock self.input_queue, but it is already locked by handle_queue() waiting for the data to be written there by handle_read(). Thus, the lock for self.stream is never released, and handle_write() never has a chance to get it.
The underlying reason is that you use locks where you shouldn't. Do not use mutexes for read/write pairs: the write thread may never get a chance to write because the read thread is holding the lock, as happened here. You should use channels for in-memory read/write, and stream splits for I/O pairs.