问题是您创建的互斥锁在connection_manager期间保持锁定。
在Rust中使用互斥锁的方式是它 Package 它锁定的数据，当你锁定互斥锁时，它会阻塞当前线程，直到它能够获得互斥锁为止，一旦它获得了，它给你一个MutexGuard，你可以把它看作是一个互斥体引用的 Package 器，MutexGuard给你一个对互斥体内部数据的可变访问。然后，一旦不再需要MutexGuard，Rust调用MutexGuard的Drop实现，它解锁互斥锁并允许其他线程获得它。

// Block until mutex is locked for this thread and return MutexGuard
let mut n = self_cloned1.lock().unwrap();

// Do stuff with the locked mutex
n.connection_manager();

// MutexGuard is no longer needed so it gets dropped and the mutex is released

如您所见，如果connection_manager从未退出，则互斥锁将保持锁定状态，直到第一个线程获得互斥锁。
您可能需要将互斥锁与condvar一起使用，以便在线程休眠时释放互斥锁。

• • 编辑：**

下面是使用condvar处理连接和使用通道将作业传递给工作线程的大致概念。Playground Link

use std::sync::{Arc, Mutex, Condvar};
use std::thread::{self, current};
use std::time::Duration;

use crossbeam_channel::{unbounded, Receiver};

#[derive(Clone, Copy)]
struct SomeNetwork {
    is_connected: bool,
}

const TIMEOUT: Duration = Duration::from_secs(5);

impl SomeNetwork {
    fn connect(&mut self) {
        println!("connection_manager thread...");
        self.is_connected = true;
    }

    fn api_calls(&self, job: i32) {
        //println!("api_calls thread...");
        println!("[Worker {:?}] Handling job {}", current().id(), job);
        thread::sleep(Duration::from_millis(50))
    }

    pub fn start_connection_thread(
        self_data: Arc<Mutex<Self>>,
        connect_condvar: Arc<Condvar>,
        worker_condvar: Arc<Condvar>,
    ) {
        thread::Builder::new()
            .spawn(move || {
                let mut guard = self_data.lock().unwrap();

                loop {
                    // Do something with the data
                    if !guard.is_connected {
                        guard.connect();

                        // Notify all workers that the connection is ready
                        worker_condvar.notify_all();
                    }

                    // Use condvar to release mutex and wait until signaled to start again
                    let (new_guard, _) = connect_condvar.wait_timeout(guard, TIMEOUT).unwrap();
                    guard = new_guard;
                }
            })
            .unwrap();
    }
    
    
    pub fn start_worker_thread(
        self_data: Arc<Mutex<Self>>,
        connect_condvar: Arc<Condvar>,
        worker_condvar: Arc<Condvar>,
        requests: Receiver<i32>,
    ) {
        thread::Builder::new()
            .spawn(move || {
                loop {
                
                    // Wait until a request is received
                    let request = requests.recv().unwrap();
                
                    // Lock mutex once we have a request
                    let mut guard = self_data.lock().unwrap();
                
                    // Make sure we are connected before starting tasks
                    while !guard.is_connected {
                        // Wake up 1 connection thread if the connection breaks
                        connect_condvar.notify_one();
                        
                        // Sleep until signaled that the connection has been fixed
                        let (new_guard, _) = worker_condvar.wait_timeout(guard, TIMEOUT).unwrap();
                        guard = new_guard;
                    }

                    // Now that we have verified we are connected, handle the request
                    guard.api_calls(request);
                    
                }
            })
            .unwrap();
    }

    pub fn start() {
        let self_arc = SomeNetwork {
            is_connected: false,
        };

        let self_arc = Arc::new(Mutex::new(self_arc));
        let connect_condvar = Arc::new(Condvar::new());
        let worker_condvar = Arc::new(Condvar::new());

        // Create a channel to send jobs to workers
        let (send, recv) = unbounded();

        Self::start_connection_thread(self_arc.clone(), connect_condvar.clone(), worker_condvar.clone());
        
        // Start some workers
        for _ in 0..5 {
            Self::start_worker_thread(self_arc.clone(), connect_condvar.clone(), worker_condvar.clone(), recv.clone());
        }
        
        // Send messages to workers
        for message in 1..100 {
            send.send(message);
        }
        

        loop {
            thread::sleep(Duration::from_millis(5000))
        }
    }
}

fn main() {
    SomeNetwork::start();
}