Moje odkazy

• Nabídka služeb
• Relational pipes
• SQL-Výuka.cz
• SQL-DK
• Nekuřák.cz
• i1984.cz
• Telekomunikační slovník

Ostatní odkazy

• GNU.org
• FSF.org
• Monča.cz

Obsah článku:

• Problém
• Co je RAII (CADRe, SBRM)
• Jak vypadá RAII v Javě
• Závěr

C++ nemá garbage collector (GC) a navíc si s sebou táhne historické dědictví jazyka C a ruční správy paměti. Proto je spousta programů v C/C++ docela peklo a udržovat kód prolezlý pointery je procházka minovým polem. Ale nemusí tomu tak být – v moderním C++ se používá princip RAII a další vymoženosti.

Problém

V programu pracujeme s hodnotami, datovými strukturami a dalšími zdroji – a potřebujeme je zavírat a uvolňovat ve chvíli, kdy už je nepotřebujeme (jinak nám dojde paměť, přetížíme síť nebo třeba přijdeme o data).

Následující (pseudo)kód funguje dobře…

// např. otevřeme soubory, síťová nebo databázová spojení atd.
Zdroj a = vytvořímeZdroj();
Zdroj b = vytvořímeZdroj();

// vlastní užitečná práce
něcoDělámeSeZdroji(a, b);

// odpojíme se, zavřeme soubory atd.
zavřemeZdroj(b);
zavřemeZdroj(a);

…ale jen v případě, že metoda něcoDělámeSeZdroji() nevyhodí výjimku. A nejen to: nesmíme na napsání posledních dvou řádků zapomenout a když tam budeme mít nějaké větvení IF/ELSE, musí být ve všech větvích nebo někde na konci.

Co je RAII (CADRe, SBRM)

Zkratka RAII znamená Resource Acquisition Is Initialization. Tenhle název je trochu kryptický – že se zdroj alokuje v době vytváření objektu není až tak překvapivé. Podstatnější je ta druhá polovina – rušení objektu a uvolňování zdroje. Také se používá zkratka CADRe: Constructor Acquires, Destructor Releases. Nebo výstižnější SBRM: Scope-Based Resource Management (viz diskuse pod článkem).

V RAII je zdroj spjatý s životním cyklem objektu. Na konci rozsahu platnosti proměnné se volá destruktor objektu a ten uvolní daný zdroj (např. zavře soubor).

Když někde vyletí výjimka, rovněž končí rozsah platnosti proměnných a uvolňují se zdroje (automaticky, aniž bychom je museli ručně zavírat).

Zdroje se uvolňují v opačném pořadí, než v jakém vznikaly. Takže když pracujeme např. s SQL databází, nejdřív se uvolní výsledková sada, pak připravený dotaz a až nakonec databázové spojení – tzn. nepodřízneme si pod sebou větev tím, že bychom nejdřív zavřeli spojení a pak až ty další zdroje (což už by bylo k ničemu).

Jak vypadá RAII v Javě

V Javě destruktory nejsou a máme metodu finalize(), kterou třída může volitelně implementovat (v předkovi java.lang.Object je prázdná). Tyto metody volá GC při rušení objektů, ovšem není zaručeno, že je zavolá ve správném pořadí a dokonce ani to, že je vůbec zavolá.

Cesta k RAII v Javě vede jinudy. Od verze 7 máme k dispozici vylepšený blok try/catch ve kterém můžeme alokovat zdroje – třídy implementující rozhraní AutoCloseable. Na konci bloku (tzn. na konci rozsahu platnosti dané proměnné) se automaticky zavolá metoda close().

Můžeme zanořit více bloků a zdroje se nám zavřou ve správném pořadí:

try (Zdroj a = new Zdroj("a", false, false, false)) {
	try (Zdroj b = new Zdroj("b", false, false, false)) {
		try (Zdroj c = new Zdroj("c", false, false, false)) {
			a.necoDelej();
			b.necoDelej();
			c.necoDelej();
		} // končí rozsah platnosti proměnné c → volá se c.close()
	} // b.close()
} // a.close()

(celý příklad najdete v mém mercurialu)

Pořadí událostí vidíme na výpisu:

Vytváříme: Zdroj [a] chyba=false
Vytváříme: Zdroj [b] chyba=false
Vytváříme: Zdroj [c] chyba=false
Něco děláme: Zdroj [a] chyba=false
Něco děláme: Zdroj [b] chyba=false
Něco děláme: Zdroj [c] chyba=false
Zavíráme: Zdroj [c] chyba=false
Zavíráme: Zdroj [b] chyba=false
Zavíráme: Zdroj [a] chyba=false

V Javě tedy můžeme dosáhnout srovnatelného efektu jako s RAII v C++. Rozdíly jsou dva:

• nestačí definovat proměnnou a jen si počkat na konec jejího rozsahu platnosti – musíme ji explicitně obalit blokem try (…) { … }, což vede k více úrovním zanoření kódu
• zdroje se zavírají ve správném pořadí, ale o uvolnění paměti se stále stará GC tzn. paměť se uvolňuje později a v nezaručeném pořadí (což zase tolik nevadí, hlavní je to zavírání zdrojů)

Ztracené výjimky

Je tu ještě jedna zajímavost. Projděte si celý příklad (viz odkaz výše) a všimněte si, že se v catch bloku odchytávají nejen výjimky vzniklé při práci se zdrojem, ale i případné výjimky vyhazované z konstruktoru zdroje (nebo obecně při jeho vytváření) a stejně tak výjimky vzniklé při jeho zavírání.

V praxi může dojít k více výjimkám najednou – např. při vytváření zdroje c a zavírání zdroje b – ale blok catch máme jen jeden a procházet se jím bude jen jednou. Vyhodí/odchytí se pouze první výjimka a další zůstanou potlačené.

Potlačené výjimky můžeme získat voláním metody getSuppressed() právě na té první výjimce.

Příklad: zdroje si vytvoříme tak, aby vyhazovaly výjimky při zavírání a zdroj c navíc tak, aby vyhodil výjimku při svém použití:

try (Zdroj a = new Zdroj("a", false, false, true)) {
	try (Zdroj b = new Zdroj("b", false, false, true)) {
		try (Zdroj c = new Zdroj("c", false, true, true)) {
…

sled událostí potom vypadá takhle:

Vytváříme: Zdroj [a] chyba=false
Vytváříme: Zdroj [b] chyba=false
Vytváříme: Zdroj [c] chyba=false
Něco děláme: Zdroj [a] chyba=false
Něco děláme: Zdroj [b] chyba=false
Něco děláme: Zdroj [c] chyba=true
Zavíráme: Zdroj [c] chyba=true
Zavíráme: Zdroj [b] chyba=true
Zavíráme: Zdroj [a] chyba=true
ChybaDělání: Zdroj [c]
	ChybaZavírání: Zdroj [c] (potlačená výjimka)
	ChybaZavírání: Zdroj [b] (potlačená výjimka)
	ChybaZavírání: Zdroj [a] (potlačená výjimka)
Finalizujeme: Zdroj [c]
Finalizujeme: Zdroj [b]
Finalizujeme: Zdroj [a]

Aby došlo k finalizaci objektů, museli jsme zavolat System.gc() a System.runFinalization() – jinak by se dříve ukončil program a metody finalize() by se nezavolaly.

Závěr

RAII v C++ není vše-spásné řešení. Takhle idylicky to totiž funguje jen pro lokální proměnné. Ve spojení s chytrými ukazateli (místo klasických surových pointerů), které počítají reference, to ale může z velké míry GC nahradit a z C++ se pak stává relativně příjemné a bezpečné prostředí.

Každý jazyk má něco do sebe a taky nějaké slabiny – počítání referencí ukazatelem není dokonalé a na druhé straně GC se zase může spustit ve chvíli, kdy se vám to zrovna nehodí.