Code shared from the Rust Playground

playground.rs

use tokio::sync::mpsc;
use tokio::sync::oneshot;
extern crate rand;
use futures::future::FutureExt;

use rand::Rng;


async fn lmao_test() {
    let (gtx, mut grx): (
        mpsc::UnboundedSender<oneshot::Sender<bool>>,
        mpsc::UnboundedReceiver<oneshot::Sender<bool>>,
    ) = mpsc::unbounded_channel();
    tokio::spawn(async move {
        let mut ctr = 0;
        loop {
            println!("WAITING");
            if let Some(i) = grx.recv().await {
                i.send(false).unwrap();
                ctr += 1;
                println!("SENT {}", ctr);
            } else {
                println!("FINISHED");
                break;
            }
        }
    });
    let mut rng = rand::thread_rng();
    let t = rng.gen_range(200, 500);
    tokio::spawn(async move {
        let mut futs = vec![];
        println!("{} times", t);
        for _ in 0..t {
            let (tx, rx) = oneshot::channel::<bool>();
            gtx.send(tx).unwrap();
            // If you remove shared(), it works
            futs.push(Box::pin(async move { rx.await.unwrap() }).shared());
        }
        let mut ctr = 0;
        for f in futs {
            println!("start {}", ctr);
            if f.await {
                panic!("iwkms");
            }
            println!("end {}", ctr);
            ctr = ctr + 1;
        }
    })
    .await;
}
fn main() {
     let mut rt = tokio::runtime::Builder::new()
        .basic_scheduler()
        .enable_all()
        .build()
        .unwrap();
    rt.block_on(async {lmao_test().await;});
}