Rust: Produkcyjne Snippet'y Kodu

Wzorce Rust: bezpieczna współbieżność, obsługa błędów, sieci, makra.

Python JavaScript TypeScript Java C# C++ Go PHP Rust SQL

Na tej stronie:

41. Rust: Bezpieczny Licznik (Arc & Mutex) 42. Rust: Parser z Result / Option 43. Rust: Własny Prosty Serwer TCP 44. Rust: Wydajne Iteratory 45. Rust: Makro Pomiaru Czasu Wykonania

41. Rust: Bezpieczny Licznik (Arc & Mutex)

Rust

Współdzielenie stanu między wieloma wątkami bez wyścigów danych.

use std::sync::{Arc, Mutex};
use std::thread;

fn create_counter() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        handles.push(thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        }));
    }
}

Kiedy używać

Stosuj, gdy wiele wątków musi modyfikować tę samą wartość współdzieloną bez ryzyka wyścigu danych (data race).

Typowe pułapki

W tym przykładzie brakuje join() na uchwytach wątków — bez tego program może zakończyć się zanim wszystkie wątki skończą pracę.

42. Rust: Parser z Result / Option

Rust

Idiomatyczna obsługa brakujących danych i błędów parsowania.

fn parse_port(s: &str) -> Result {
    s.trim().parse::()
}

Kiedy używać

Idiomatyczny sposób obsługi błędów w Rust — zamiast wyjątków, funkcja jawnie informuje typem zwracanym, że coś może się nie udać.

Typowe pułapki

Używanie .unwrap() zamiast dopasowania wzorca (match) czy operatora ? na wyniku Result powoduje panic przy błędnych danych wejściowych.

43. Rust: Własny Prosty Serwer TCP

Rust

Obsługa połączeń przychodzących z wykorzystaniem wielowątkowości.

use std::net::TcpListener;

fn run_server() -> std::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:8080")?;
    for stream in listener.incoming() {
        let _stream = stream?;
        // Obsługa połączenia...
    }
    Ok(())
}

Kiedy używać

Punkt startowy do zrozumienia jak działają serwery sieciowe w Rust, zanim sięgniesz po framework jak Tokio.

Typowe pułapki

Ten przykład obsługuje połączenia sekwencyjnie — prawdziwy serwer produkcyjny potrzebuje wielowątkowości albo asynchroniczności (async/await).

44. Rust: Wydajne Iteratory

Rust

Przetwarzanie kolekcji z optymalizacjami kompilatora.

fn sum_evens(numbers: &[i32]) -> i32 {
    numbers.iter()
           .filter(|&&x| x % 2 == 0)
           .sum()
}

Kiedy używać

Preferuj iteratory nad pętlami for z indeksami — kompilator Rust potrafi je zoptymalizować równie dobrze, a kod jest czytelniejszy.

Typowe pułapki

Nadmierne łańcuchowanie iteratorów bez potrzeby (map po map po filter) może utrudnić czytanie kodu bardziej niż zwykła pętla.

45. Rust: Makro Pomiaru Czasu Wykonania

Rust

Mierzenie wydajności fragmentów kodu w sposób przejrzysty.

macro_rules! time_it {
    ($body:expr) => {
        let start = std::time::Instant::now();
        let _res = $body;
        println!("Czas wykonania: {:?}", start.elapsed());
    };
}

Kiedy używać

Przydatne do szybkiego profilowania fragmentu kodu bez sięgania po zewnętrzne narzędzia profilujące.

Typowe pułapki

Wynik pomiaru czasu w trybie debug bywa znacząco wolniejszy niż w release — zawsze mierz wydajność na buildzie zoptymalizowanym.