Tulajdonlás & Kölcsönzés versus Referenciaszámlálás

A tulajdonlási modell a Rust alapvető innovációja. Minden heap-allokációnak pontosan egy tulajdonosa van — az a változókötés, amelyik „tartja" azt. A tulajdonjog átruházható egy másik kötésre, ekkor az eredeti érvénytelenné válik. Sohasem másolódik csendben (hacsak a típus nem implementálja a Copy traitot).

Mozgás Szemantika

fn main() {
    let s1 = String::from("helló");
    let s2 = s1;  // tulajdonjog ÁTRUHÁZVA — s1 mostantól érvénytelen

    // println!("{}", s1);  ← fordítási hiba: érték mozgatás után kölcsönözve
    println!("{}", s2);  // rendben — s2 az egyetlen tulajdonos
} // s2 itt kerül felszabadításra, a memória automatikusan törlődik

A borrow checker érvényesíti a tulajdonlási szabályokat. Amikor s1-et s2-höz rendeljük, a fordító megérti, hogy s1 nem használható tovább — lemondott a tulajdonjogáról. Ez nullás futásidei költséggel szünteti meg a use-after-free hibákat.

Kölcsönzés — Megosztott (&T) és Módosítható (&mut T)

A tulajdonjog mindenhová való átruházása kényelmetlen lenne. A Rust lehetővé teszi az értékek kölcsönzését: ideiglenes, hatókörbe zárt referencia felvételét a tulajdonjog átadása nélkül.

fn hossz_kiszamitas(s: &String) -> usize {
    s.len()
}  // s kikerül a hatókörből, de NEM szabadítja fel a String-et

fn vilag_hozzaadasa(s: &mut String) {
    s.push_str(", világ");
}

fn main() {
    let mut udvozles = String::from("helló");

    let hossz = hossz_kiszamitas(&udvozles); // megosztott kölcsönzés
    vilag_hozzaadasa(&mut udvozles);          // módosítható kölcsönzés

    println!("'{}' {} karakterből áll", udvozles, hossz);
}

A borrow checker egyszerre kényszerít ki két invariánst:

• Tetszőleges számú megosztott (&T) kölcsönzés élhet egyszerre — ezek csak olvashatók és nem aliasálhatnak mutációt.
• Egyszerre pontosan egy módosítható (&mut T) kölcsönzés létezhet — és megosztott kölcsönzéssel nem lehet egyidejű.

Ez az aliasálás VAGY mutálhatóság — egy alapvető szabály, amely statikusan szünteti meg a hibák egész kategóriáit (iterátor-invalidáció, adatversenyek).

Élettartamok

A referenciák élettartam-annotációkkal egészülnek ki — ezek bizonyítják, hogy a referencia nem élheti túl azt az adatot, amelyre mutat. A legtöbb kódban a fordító kikövetkezteti ezeket; összetett generikus API-kban explicit módon kell megadni.

// 'a azt jelenti: a visszaadott referencia legalább annyit él, mint mindkét bemenet
fn hosszabb<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() >= y.len() { x } else { y }
}

A tulajdonlás egy szigorú, egyetlen-tulajdonos modell. Ám egyes programok megosztott tulajdonlást igényelnek — a program több részének is életben kell tartania ugyanazt az értéket. A klasszikus példa egy gráf, ahol több él mutat ugyanarra a csúcsra.

Az Rc<T> (Reference Counted — Referenciaszámlált) egy értéket csomagol be a heap-en, két számlálóval együtt: egy erős számlálóval (aktív tulajdonosok) és egy gyenge számlálóval. Minden Rc-klón növeli az erős számlálót; minden drop csökkenti. Amikor az erős számláló nullára csökken, a belső érték felszabadul.

Alaphasználat

use std::rc::Rc;

fn main() {
    let a = Rc::new(String::from("megosztott adat"));
    let b = Rc::clone(&a);  // erős számláló növelése — olcsó mutatómásolás
    let c = Rc::clone(&a);

    println!("erős számláló = {}", Rc::strong_count(&a)); // 3

    drop(b);
    println!("b eldobása után = {}", Rc::strong_count(&a)); // 2

} // a és c itt esik el; számláló → 0 → String felszabadul

Belső Módosíthatóság RefCell-lel

Az Rc<T> megosztott tulajdonlást biztosít, de csak olvasható hozzáférést. A belső érték módosításához párosítani kell RefCell<T>-lel, amely a kölcsönzés-ellenőrzést fordítási időből futásidőre helyezi:

use std::rc::Rc;
use std::cell::RefCell;

fn main() {
    let megosztott = Rc::new(RefCell::new(vec![1, 2, 3]));

    let klon1 = Rc::clone(&megosztott);
    let klon2 = Rc::clone(&megosztott);

    klon1.borrow_mut().push(4);  // futásidei kölcsönzés-ellenőrzés
    klon2.borrow_mut().push(5);

    println!("{:?}", megosztott.borrow()); // [1, 2, 3, 4, 5]
}

Szálbiztos Megosztás: Arc<T>

Az Rc<T> nem Send vagy Sync — a számlálója nem atomikus, és nem léphet át szálhatárokon. Párhuzamos használathoz cseréljük le Arc<T>-re (Atomically Reference Counted — Atomikusan Referenciaszámlált), amely atomikus CPU-műveleteket használ a számlálóhoz. Szálak közötti belső módosíthatósághoz párosítsuk Mutex<T>-vel vagy RwLock<T>-lal.

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

fn main() {
    let szamlalo = Arc::new(Mutex::new(0u32));

    let szalak: Vec<_> = (0..8).map(|_| {
        let sz = Arc::clone(&szamlalo);
        thread::spawn(move || {
            *sz.lock().unwrap() += 1;
        })
    }).collect();

    for szal in szalak { szal.join().unwrap(); }
    println!("számláló = {}", *szamlalo.lock().unwrap()); // 8
}

Teljesítmény a Gyakorlatban

Az Rc<T> többletköltsége háromrétű: egy extra heap-allokáció a vezérlőblokknak, egy mutatókövetés minden hozzáférésnél, és két egész-növelés/csökkentés klónoláskor és felszabadításkor. A legtöbb program esetében ez elhanyagolható. Másodpercenként millió műveletet végző forró kódban — játékmotorok, fordítók, jelelfeldolgozók esetén — a tulajdonolt értékek előnyben részesítése számít.

Az Arc<T> további költséget jelent: az atomikus műveletek CPU memóriarendezési garanciákat (SeqCst vagy Release/Acquire) igényelnek, amelyek gátolnak bizonyos fordítói és hardveres átrendezéseket. Versenyző többmagos munkaterheléseknél ez mérhetővé válhat.

Válassz Tulajdonlást + Kölcsönzést, ha…

• Az adatnak egyértelmű egyetlen logikai tulajdonosa van (legtöbb struct, kollekció, I/O erőforrás).
• Determinisztikus, minimális többletköltségű felszabadításra van szükség (RAII fájlokhoz, socketekhez, zárakhoz).
• Könyvtárkódot írunk, ahol a hívók szabályozzák az élettartamokat.
• A teljesítmény kritikus és minden allokáció számít.

Válassz Rc<T> / Arc<T>-t, ha…

• Több tulajdonosnak valóban életben kell tartania ugyanazt az adatot (gráfcsúcsok, szintaxisfák, eseményfigyelők).
• Az adat élettartama dinamikusan, futásidőben dől el, nem statikusan.
• Külső rendszerekkel dolgozunk, amelyek referencia-szemantikát várnak (Python bővítmények, GUI keretrendszerek).
• Szálak között szeretnénk megosztott állapotot nagy struktúrák másolása nélkül (Arc<Mutex<T>>).

// Klasszikus felhasználási eset: gráf megosztott csúcsokkal
use std::rc::{Rc, Weak};
use std::cell::RefCell;

struct Csucs {
    ertek: i32,
    gyerekek: Vec<Rc<RefCell<Csucs>>>>,
    szulo: Option<Weak<RefCell<Csucs>>>>, // Weak töri meg a szülő→gyerek kört
}

impl Csucs {
    fn uj(ertek: i32) -> Rc<RefCell<Csucs>> {
        Rc::new(RefCell::new(Csucs {
            ertek,
            gyerekek: vec![],
            szulo: None,
        }))
    }
}