Problemi a vita che condividono riferimenti tra thread

Ho una discussione che avvia thread di lavoro, ci si aspetta che tutti vivano per sempre. Ogni thread di lavoro mantiene la propria lista di Socket .

Alcune operazioni richiedono che io attraversi tutte le prese attualmente in vita, ma ho problemi con le durate che provano a creare un elenco principale di socket contenenti un puntatore a un socket di proprietà di un altro elenco.

 use std::{str, thread}; use std::thread::JoinHandle; use std::io::{Read, Write}; use std::net::{TcpListener, TcpStream}; use std::sync::{Arc, Mutex}; use std::ops::DerefMut; use std::sync::mpsc::{channel, Sender, Receiver, TryRecvError}; use self::socketlist::SocketList; use self::mastersocketlist::MasterSocketList; pub struct Socket { user: String, stream: TcpStream, } mod socketlist { use self::SocketList::{Node, End}; use super::Socket; pub enum SocketList { Node(Socket, Box), End, } impl SocketList { pub fn new() -> SocketList { End } pub fn add(self, socket: Socket) -> SocketList { Node(socket, Box::new(self)) } pub fn newest(&'a mut self) -> Result { match *self { Node(ref mut socket, ref mut next) => Ok(socket), End => Err("No socket available".to_string()), } } } } mod mastersocketlist { use self::MasterSocketList::{Node, End}; use super::Socket; pub enum MasterSocketList { Node(Box, Box<MasterSocketList>), End, } impl MasterSocketList { pub fn new() -> MasterSocketList { End } pub fn add(self, socket: &'a Socket) -> MasterSocketList { MasterSocketList::Node(Box::new(&socket), Box::new(self)) } } } pub struct SlotManager { prox: JoinHandle, prox_tx: Sender, } impl SlotManager { pub fn new() -> SlotManager { let (tx, rx): (Sender, Receiver) = channel(); let tx_clone = tx.clone(); let prox = thread::spawn(move || SlotManager::event_loop(tx, rx)); SlotManager { prox: prox, prox_tx: tx_clone, } } pub fn sender(&self) -> Sender { self.prox_tx.clone() } fn event_loop(tx: Sender, rx: Receiver) { let socket_list = Arc::new(Mutex::new(MasterSocketList::new())); let mut slot = Slot::new(socket_list.clone()); loop { match rx.try_recv() { Ok(stream) => slot.new_connection(stream), Err(e) => {} } } } } pub struct Slot { prox: JoinHandle, prox_tx: Sender, } impl Slot { pub fn new(master_socket_list: Arc<Mutex>) -> Slot { let (tx, rx): (Sender, Receiver) = channel(); let tx_clone = tx.clone(); let prox = thread::spawn(move || Slot::event_loop(tx, rx, master_socket_list)); Slot { prox: prox, prox_tx: tx_clone, } } pub fn new_connection(&self, stream: TcpStream) { self.prox_tx.send(stream); } fn event_loop(tx: Sender, rx: Receiver, master_socket_list: Arc<Mutex>) { let mut sockets = SocketList::new(); loop { // Check for new connections match rx.try_recv() { Ok(stream) => { let mut socket = Socket { user: "default".to_string(), stream: stream, }; sockets = sockets.add(socket); let mut msl_guard = match master_socket_list.lock() { Ok(guard) => guard, Err(poisoned) => poisoned.into_inner(), }; let mut msl_handle = msl_guard.deref_mut(); *msl_handle = msl_handle.add(sockets.newest().unwrap()); } Err(e) => {} } } } } fn main() { let mut slot_manager = SlotManager::new(); let listener = TcpListener::bind("127.0.0.1:1234").unwrap(); for stream in listener.incoming() { match stream { Ok(stream) => { let sender = slot_manager.sender(); thread::spawn(move || { sender.send(stream); //process_new_connection(stream, sender) }); } Err(e) => println!("Connection error: {}", e), } } drop(listener); } 

Gli errori che ricevo …

 error[E0477]: the type `[closure@src/main.rs:107:34: 107:86 tx:std::sync::mpsc::Sender, rx:std::sync::mpsc::Receiver, master_socket_list:std::sync::Arc<std::sync::Mutex<mastersocketlist::MasterSocketList>>]` does not fulfill the required lifetime --> src/main.rs:107:20 | 107 | let prox = thread::spawn(move || Slot::event_loop(tx, rx, master_socket_list)); | ^^^^^^^^^^^^^ | = note: type must outlive the static lifetime 

Non so nemmeno se quello che sto cercando sia ansible come codice sicuro.

Voglio che la mastersocketlist contenga un puntatore a un socket in cui la durata del socket è definita dal thread che lo ha creato. Credo che sia quello che significano tutti quegli errori, ma non ho idea di come fornire le annotazioni di durata per correggerlo.