Rust ha un equivalente del threading di Python. Timer?

Question

Sto cercando un timer che utilizza i thread, non semplice time.sleep:

from threading import Timer 

def x(): 
    print "hello" 
    t = Timer(2.0, x) 
    t.start() 

t = Timer(2.0, x) 
t.start() 

Answer 1

È possibile utilizzare il timer cassa

extern crate timer; 
extern crate chrono; 

use timer::Timer; 
use chrono::Duration; 
use std::thread; 

fn x() { 
    println!("hello"); 
} 

fn main() { 
    let timer = Timer::new(); 
    let guard = timer.schedule_repeating(Duration::seconds(2), x); 
    // give some time so we can see hello printed 
    // you can execute any code here 
    thread::sleep(::std::time::Duration::new(10, 0)); 
    // stop repeating 
    drop(guard); 
} 

Answer 2

E 'abbastanza facile scrivere una versione simile da soli, utilizzando solo strumenti dalla libreria standard:

use std::thread; 
use std::time::Duration; 

struct Timer<F> { 
    delay: Duration, 
    action: F, 
} 

impl<F> Timer<F> 
where 
    F: FnOnce() + Send + Sync + 'static, 
{ 
    fn new(delay: Duration, action: F) -> Self { 
     Timer { delay, action } 
    } 

    fn start(self) { 
     thread::spawn(move || { 
      thread::sleep(self.delay); 
      (self.action)(); 
     }); 
    } 
} 

fn main() { 
    fn x() { 
     println!("hello"); 
     let t = Timer::new(Duration::from_secs(2), x); 
     t.start(); 
    } 

    let t = Timer::new(Duration::from_secs(2), x); 
    t.start(); 

    // Wait for output 
    thread::sleep(Duration::from_secs(10)); 
} 

Come pointed out by malbarbo, questo vuol creare una nuova thre annuncio per ogni timer. Questo può essere più costoso di una soluzione che riutilizza i thread ma è un esempio molto semplice.