Sledujme některé další rozdíly mezi Thread a Runnable pomocí srovnávací tabulky uvedené níže:
Srovnávací graf
| Základ pro porovnání | Vlákno | Runnable |
|---|---|---|
| Základní | Každé vlákno vytvoří jedinečný objekt a dostane se k němu přiřazeno. | Více podprocesů sdílí stejné objekty. |
| Paměť | Jak každý podproces vytvořit jedinečný objekt, vyžaduje více paměti. | Protože více podprocesů sdílí stejný objekt, používá se méně paměti. |
| Prodloužení | V Javě, více dědictví není povoleno, proto, po třídě rozšiřuje Thread třídy, nemůže rozšířit žádné jiné třídy. | Pokud třída definuje vlákno implementující rozhraní Runnable, má šanci na rozšíření jedné třídy. |
| Použití | Uživatel musí rozšířit třídu podprocesů pouze v případě, že chce přepsat jiné metody ve třídě podprocesů. | Pokud se chcete specializovat pouze na metodu běhu, pak implementace Runnable je lepší volba. |
| Spojení | Rozšíření Třída závitu zavádí těsné propojení, protože třída obsahuje kód třídy Závit a také úlohu přiřazenou k vláknu | Implementace rozhraní Runnable zavádí volnou vazbu, protože kód podprocesu je oddělený od úlohy podprocesů. |
Definice třídy závitu
Vlákno je třída v balíčku java.lang . Třída podprocesů rozšiřuje třídu Object a implementuje rozhraní Runnable . Třída podprocesů obsahuje konstruktory a metody pro vytváření a provozování podprocesu. Když vytvoříme více podprocesů, každý podproces vytvoří jedinečný objekt a dostane se k němu přiřazen. Pokud vytvoříte vlákno, které rozšiřuje třídu podprocesů, nemůžete rozšířit žádnou jinou třídu, protože java nepodporuje více dědičností. Měli byste proto zvolit rozšíření třídy podprocesů pouze tehdy, chcete-li přepsat některé jiné metody třídy podprocesů. Podívejme se na příklad vytvoření podprocesu rozšiřujícího třídu podprocesů.
/ * Definování podprocesu * / Třída Mythread rozšiřuje podproces {/ * úloha podprocesu * / public void run () {for (int i = 0; i <10; i ++) {System.Out.Println ("Podřízené vlákno" ); }} Třída mainThread {/ * úloha hlavního vlákna * / public static void main (String args []) {Mythread mt = new Mythread (); / * hlavní podproces vytvořil podřízený podproces * / mt.start (); pro (int i = 0; i <10; i ++) {System.Out.Print ("Hlavní vlákno"); }}} / * Výstup * / Hlavní vlákno Hlavní vlákno Hlavní vlákno Hlavní vlákno Hlavní vlákno Podřízené vlákno Podřízené vlákno Podřízené vlákno Podřízené vlákno Podřízené vlákno Podřízené vlákno Hlavní vlákno Podproces Hlavní podproces Hlavní podproces Hlavní vlákno Podproces Podřízený podproces Hlavní podproces Hlavní podproces Hlavní podproces Podřízený podproces Podřízený podproces Hlavní vlákno Hlavní vlákno Ve výše uvedeném kódu vytvořím třídu Mythread, která rozšiřuje třídu Thread a přepíše způsob spuštění třídy Thread. Ve třídě obsahující hlavní metodu vytvořím objekt podprocesu (mt) třídy Mythread a pomocí objektu podprocesu vyvolaného metodou start (). Metoda start zahajuje provádění podprocesu a zároveň JVM vyvolá metodu spuštění podprocesu. Nyní jsou v programu dvě podprocesy a hlavní podproces je vytvořen druhý podřízený podproces. Provádění obou závitů probíhá současně, ale přesný výstup nelze předstírat.
Definice Runnable Interface
Runnable je rozhraní v balíčku java.lang . Implementace Runnable rozhraní můžeme definovat vlákno. Rozhraní Runnable má jednu metodu run (), která je implementována třídou, která implementuje rozhraní Runnable. Pokud se rozhodnete definovat podproces implementující rozhraní Runnable, stále máte možnost rozšířit libovolnou jinou třídu. Pokud vytvoříte více podprocesů implementací rozhraní Runnable, každý podproces sdílí stejnou instanci runnable. naučme se definovat vlákno pomocí rozhraní Runnable.
/ * Definování podprocesu * / Třída Runnablethread implementuje Runnable {/ * úlohu podprocesu * / public void run () {for (int i = 0; i <10; i ++) {System.Out.Println ("Podřízené vlákno" ); }} Třída mainThread {/ * úloha hlavního vlákna * / public static void main (String args []) {Mythread rt = new Mythread (); / * hlavní vlákno vytvořilo objekt runnable * / Thread t = new Thread (rt); / * hlavní podproces vytvoří podřízený podproces a předá objekt runnable * / t.start (); pro (int i = 0; i <10; i ++) {System.Out.Print ("Hlavní vlákno"); }}} / * Výstup * / Hlavní vlákno Hlavní vlákno Hlavní vlákno Hlavní vlákno Hlavní vlákno Podřízené vlákno Podřízené vlákno Podřízené vlákno Podřízené vlákno Podřízené vlákno Podřízené vlákno Hlavní vlákno Podproces Hlavní podproces Hlavní podproces Hlavní vlákno Podproces Podřízený podproces Hlavní podproces Hlavní podproces Hlavní podproces Podřízený podproces Podřízený podproces Hlavní vlákno Hlavní vlákno Ve výše uvedeném kódu jsem vytvořil třídu Runnablethread, která implementuje rozhraní Runnable a definuje úlohu podprocesu implementací metody run () rozhraní Runnable. Potom vytvořím třídu mainthread obsahující hlavní metodu. Uvnitř hlavní metody jsem deklaroval objekt runnable třídy Runnablethread a předal tento objekt konstruktoru podprocesu při deklaraci podprocesu. Tímto způsobem jsem propojil objekt vlákna (t) s objektem runnable (rt). Objekt podprocesu pak vyvolá metodu startu podprocesu, který dále vyvolá způsob spuštění třídy Runnablethread. Pokud jsem nespojil runnable objekt s objektem Thread, pak by metoda startů vláken vyvolala metodu run třídy Thread. Nyní, opět tam jsou dvě vlákna v kódu, hlavní vlákno a hlavní vlákno vytváří podřízené vlákno obojí se provádí současně, ale přesný výstup nikdy nemůže být předstírá.
Klíčové rozdíly mezi vlákny a Runnable v jazyce Java
- Každý podproces vytvořený rozšířením třídy podprocesů pro něj vytvoří jedinečný objekt a dostane se k němu přiřazen. Na druhou stranu každý podproces vytvořený implementací rozhraní Runnable sdílí stejnou instanci runnable.
- Protože každý podproces je spojen s jedinečným objektem, když je vytvořen rozšířením třídy podprocesů, je vyžadováno více paměti. Na druhou stranu každé vlákno vytvořené implementací rozhraní Runnable sdílí stejný prostor objektů, proto vyžaduje méně paměti.
- Pokud rozšíříte třídu Thread pak dále, můžete zdědit jakoukoliv jinou třídu, protože Java neumožňuje vícenásobnou dědičnost, zatímco implementace Runnable stále poskytuje šanci třídě, aby zdědila jinou třídu.
- Třídu nití je třeba rozšířit pouze tehdy, pokud má přepsat nebo se specializovat na některé jiné metody třídy vláken. Pokud chcete specializovat pouze metodu spuštění, musíte implementovat rozhraní Runnable.
- Rozšíření třídy Závit zavádí těsné propojení v kódu, protože kód Závitu a úloha podprocesu je obsažena ve stejné třídě. Na druhé straně implementace Runnable rozhraní zavádí volné spojení v kódu, protože kód Thread je seprate z úlohy přiřazené vláknu.
Závěr:
Je výhodné implementovat rozhraní Runnable namísto rozšiřování třídy podprocesů. Jak implementace Runnable dělá váš kód volně spojený, protože kód vlákna je odlišný od třídy, která přiřazuje úlohu vláknu. Vyžaduje méně paměti a také umožňuje třídě zdědit jakoukoli jinou třídu.
