`Instant` în Rust

Timp: Instant, Duration, SystemTime Rust 1.8

Un moment de timp măsurat de un ceas care doar crește; folosit pentru a măsura cât durează o operație.

Sintaxă

use std::time::Instant;

fn now() -> Instant
fn elapsed(&self) -> Duration
fn duration_since(&self, earlier: Instant) -> Duration

Ce face `Instant`

Instant::now() citește un ceas monoton: nu sare înapoi dacă cineva schimbă ora calculatorului. Valoarea nu are sens singură (nu e o dată sau o oră), dar diferența dintre două Instant-uri este o durată exactă. De aceea este instrumentul potrivit pentru măsurarea performanței și pentru limite de timp.

start.elapsed() dă timpul trecut de la start până acum. mai_tarziu.duration_since(mai_devreme) dă diferența dintre două momente; dacă ordinea este inversă, rezultatul este zero (din Rust 1.60), iar checked_duration_since dă None. Poți aduna o durată: start + Duration::from_secs(5) este un termen limită.

Pentru data și ora din calendar folosește SystemTime.

Parametri

Parametru	Descriere
`earlier`	La `duration_since`: momentul mai vechi.

Ce returnează

now: un Instant. elapsed și duration_since: o Duration.

Exemple

Exemplul 1: Cât durează un calcul

Durata exactă depinde de calculator și diferă la fiecare rulare.

use std::time::Instant;

fn main() {
    let start = Instant::now();
    let suma: u64 = (1..=1_000_000u64).map(|x| x * x).sum();
    let durata = start.elapsed();

    println!("suma pătratelor: {suma}");
    println!("a durat: {durata:?} ({} µs)", durata.as_micros());
}

Rezultat posibil (diferă la fiecare rulare)

suma pătratelor: 333333833333500000
a durat: 3.517208ms (3517 µs)

Exemplul 2: duration_since și ordinea momentelor

Afișăm doar comparații, care dau mereu același rezultat. Diferența „în sens invers” este zero, iar checked_duration_since o semnalează cu None.

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

fn main() {
    let inceput = Instant::now();
    thread::sleep(Duration::from_millis(20));
    let sfarsit = Instant::now();

    let durata = sfarsit.duration_since(inceput);
    println!("cel puțin 20 ms: {}", durata >= Duration::from_millis(20));
    println!("elapsed >= durata: {}", inceput.elapsed() >= durata);

    println!("invers: {:?}", inceput.duration_since(sfarsit));
    println!("invers, checked: {:?}", inceput.checked_duration_since(sfarsit));
}

Rezultat

cel puțin 20 ms: true
elapsed >= durata: true
invers: 0ns
invers, checked: None

Exemplul 3: Termen limită pentru încercări

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

fn main() {
    let termen = Instant::now() + Duration::from_millis(100);
    let mut incercari = 0;
    while Instant::now() < termen {
        incercari += 1;
        thread::sleep(Duration::from_millis(30));
    }
    println!("cel mult 4 încercări în 100 ms: {}", (1..=4).contains(&incercari));
}