Hat Rust ein Pendant zu Pythons threading.Timer?

Question

Ich suche einen Timer, die Threads verwendet, nicht glatt 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

Sie die timer Kiste verwenden können

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

Es ist leicht genug, um eine ähnliche Version selbst, nur mit Werkzeugen schreiben aus der Standardbibliothek:

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)); 
} 

Als pointed out by malbarbo, so liegt ein neues dre schafft Anzeige für jeden Timer. Dies kann teurer sein als eine Lösung, die Threads wiederverwendet, aber es ist ein sehr einfaches Beispiel.