thread::sleep în Rust

pub fn sleep(dur: Duration)

Ce face thread::sleep

thread::sleep(Duration::from_millis(500)) pune firul curent în așteptare cel puțin jumătate de secundă. Sistemul de operare poate să-l trezească puțin mai târziu, dar niciodată mai devreme. Celelalte fire nu sunt afectate.

Se folosește pentru pauze între încercări, pentru a limita viteza unor cereri sau în exemple care simulează o operație lentă. Nu folosi sleep ca metodă de sincronizare între fire („aștept 100 ms și sper că a terminat”); pentru asta există join, canale și Mutex.

Parametri

Parametru	Descriere
dur	Durata minimă a pauzei, ca Duration.

Ce returnează

Nimic.

Exemple

Exemplul 1: Pauză măsurată

Timpul exact diferă la fiecare rulare, așa că verificăm doar că pauza a durat cel puțin cât am cerut.

use std::thread;
use std::time::{Duration, Instant};

fn main() {
    let start = Instant::now();
    for incercare in 1..=3 {
        println!("încercarea {incercare}...");
        thread::sleep(Duration::from_millis(50));
    }
    let durata = start.elapsed();
    println!("a durat cel puțin 150 ms: {}", durata >= Duration::from_millis(150));
}

Rezultat

încercarea 1...
încercarea 2...
încercarea 3...
a durat cel puțin 150 ms: true

Exemplul 2: Durata reală a pauzelor

Valorile diferă puțin de la o rulare la alta.

use std::thread;
use std::time::{Duration, Instant};

fn main() {
    let cerut = Duration::from_millis(200);
    let start = Instant::now();
    thread::sleep(cerut);
    println!("pauză cerută: {cerut:?}, pauză reală: {:?}", start.elapsed());
}

Rezultat posibil (diferă la fiecare rulare)

pauză cerută: 200ms, pauză reală: 201.229708ms

Greșeli frecvente

• Dai un număr simplu: thread::sleep(500) nu compilează. Funcția primește un Duration.
• Folosești thread::sleep în cod async: blochează tot firul executorului. Acolo se folosește funcția de pauză a runtime-ului.

Comenzi înrudite

• Duration: O durată de timp (secunde și nanosecunde), creată cu from_secs, from_millis; se poate aduna, înmulți și compara.
• Instant: Un moment de timp măsurat de un ceas care doar crește; folosit pentru a măsura cât durează o operație.
• thread::spawn: Pornește un fir de execuție nou care rulează funcția dată; join() așteaptă terminarea lui și îi dă rezultatul.