（1）There is a task queue that uses Arc<tokio::sync::Mutex>
（2）There is another thread for IO read and write split,where the write thread reads data from the task queue
（3）The IO read-write thread uses select! for composition

when the socket disconnect, the read_task exits first，causing the write_task to be canceled.....However, the lock of Mutex inside the io_write_thread does not seem to be released...

let read_task = tokio::spawn(async move {
    read_from_bus(client_reader, read_from_net_buffer).await
});

let write_task = tokio::spawn(async move {
    write_to_bus(client_writer,task_receiver).await
});

    tokio::select! {
                e = read_task =>{
                     error!("({}) error:{:?}", bus_addr, e);
                },
                e = write_task =>{
                     error!("({}) error:{:?}", bus_addr, e);
                },
    
            }

  task_receiver.


async fn write_to_bus(mut writer: OwnedWriteHalf, task_recviver:Arc<Mutex<mpsc::Receiver<String>) -> anyhow::Result<()> {

let task_receiver = Arc::clone(&socket_receiver);
let msg_receiver = socket_receiver.lock.await;
loop{
     match msg_receiver.recv().await {
                    None => { return; }
                    Some(d) => { send(d) }
                };
}

}


---------

after socket disconnect,if i create another task,the task_receiver.lock is deallock

1 post - 1 participant

Read full topic