A pattern for correctly managing worker threads associated with an instance in Rust

manager_pattern.rs

struct Server;

impl Server {
    fn new() -> Server {
        Server
    }
}

struct ServerMgr {
    server: Arc<Server>,

    running: Arc<AtomicBool>,
    worker: Option<JoinHandle<()>>,
}

impl ServerMgr {
    fn init(server: Server) -> ServerMgr {
        let server = Arc::new(server);
        let running = Arc::new(AtomicBool::new(true));

        // Start worker thread
        let server_ref = server.clone();
        let running_ref = running.clone();
        let worker = Some(thread::spawn(move || Self::worker(server_ref, running_ref)));

        ServerMgr { server, running, worker }
    }

    fn worker(server: Arc<Server>, running: Arc<AtomicBool>) {
        while running.load(Ordering::Relaxed) {
            // Do something with the server here
        }
    }

    fn server(&self) -> &Arc<Server> { &self.server }
}

impl Drop for ServerMgr {
    fn drop(&mut self) {
        self.running.store(false, Ordering::Relaxed);
        self.worker.take().map(|w| w.join());
    }
}

fn main() {
    let server_mgr = ServerMgr::init(Server::new());
}