Why tokio::select! chooses an action with a higher frequency? - rust

Question

I have two asynchronous functions. One of them writes to the channel every second , and the other reads:
#[derive(Debug)]
pub struct Message{
content:String,
id:i32
}
impl Message {
pub fn new(s : String,id:i32) -> Message{
Message {
content:s,
id
}
}
}
async fn msg_stream(sender : mpsc::Sender<Message>) {
loop{
tokio::time::sleep(Duration::from_secs(1)).await;
let m = Message::new("abc".to_string(),1);
println!("message = {:?}",m);
if let Err(e) = sender.send(m).await{
println!("channel is closed,{}",e);
break
}
}
}
async fn read_stream(mut receiver : mpsc::Receiver<Message>){
let (tx, mut rx) = oneshot::channel::<()>();
loop{
tokio::select! {
Err(_) = tokio::time::timeout(Duration::from_secs(3),& mut rx) => {
println!("time has elapsed");
break
}
message = receiver.recv() =>{
println!("was receiver message = {:?} ",message)
}
}
}
println!("END OF STREAM");
}
#[tokio::main]
async fn main() {
let (tx,rx) = mpsc::channel::<Message>(8);
tokio::join!(msg_stream(tx),read_stream(rx));
println!("end of the programm");
}
And with these parameters, that is, messages are sent every second and the reader must break after 3. The timeout message does not come.That is, the function receives messages indefinitely.
...
message = Message { content: "abc", id: 1 }
was receiver message = Some(Message { content: "abc", id: 1 })
message = Message { content: "abc", id: 1 }
was receiver message = Some(Message { content: "abc", id: 1 })
message = Message { content: "abc", id: 1 }
...
But if i change the parameters that the message is sent every 3 seconds
tokio::time::sleep(Duration::from_secs(3)).await;
, the output will be like this:
time has elapsed
END OF STREAM
message = Message { content: "abc", id: 1 }
channel was closed,channel closed
end of programm
It is unclear why this is happening. Shouldn't select select branches randomly? or is the problem not in this, but in the fact that the message about the expiration of time is lost?

Answer 1

It is unclear why this is happening. Shouldn't select select branches randomly?
That's only relevant when multiple branches are ready when select is invoked.
In the first snippet that's never the case (since a message is sent every second there's always a message that's ready to read, and timeout is never hit).
In the second snippet, you have a race between:
a 3s async timeout
a 3s async timeout + printing to stdout (a blocking IO call) + sending through a channel
The odds that (2) will ever win that race are basically non-existent. It might be possible due to the implementation details of tokio, but I wouldn't like to bet anything of value on ever witnessing it.