A szálosztály és a futtatható interfész közötti különbség Java-ban

2019

A szál kétféleképpen definiálható. Először azáltal, hogy kiterjeszti a Thread osztályt, amely már megvalósította a Runnable interfészt. Másodszor, a Runnable interfész közvetlen megvalósításával . Ha egy menetet a Thread osztály meghosszabbításával definiál, felül kell írnia a futási () metódust a Thread osztályban. Ha meghatároz egy szálat, amely egy Runnable felületet hajt végre, akkor végre kell hajtania a Runnable interfész egyetlen futtatását (). A Thread és a Runnable közötti alapvető különbség az, hogy a Thread osztály kiterjesztésével meghatározott egyes szálak egyedi objektumot hoznak létre, és hozzárendelik az adott objektumhoz. Másrészt, a Runnable interfész megvalósításával meghatározott minden szál ugyanazt az objektumot osztja meg.

Figyeljük meg a Thread és a Runnable közötti különbségeket az alábbi táblázat segítségével:

Összehasonlító táblázat

Az összehasonlítás alapja	cérna	futtatható
Alapvető	Mindegyik szál egyedi objektumot hoz létre, és hozzá kapcsolódik.	Több szál ugyanazokat a tárgyakat osztja meg.
memória	Mivel minden szál egyedi objektumot hoz létre, több memória szükséges.	Mivel több szál ugyanazzal az objektummal rendelkezik, kevesebb memóriát használnak.
Kiterjedő	Java-ban a többszörös öröklés nem megengedett, ezért egy osztály kiterjesztése után a szálosztály nem nyújthat más osztályt.	Ha egy osztály meghatározza a futófelületet megvalósító fonalat, akkor esélye van egy osztály kiterjesztésére.
Használat	A felhasználónak csak akkor kell kiterjesztenie a szálosztályt, ha felül akarja felülírni a Thread osztály többi módját.	Ha csak a futási módszerre kíván szakosodni, akkor a Runnable végrehajtása jobb megoldás.
tengelykapcsoló	A Thread osztály kiterjesztése szoros összekapcsolást vezet be, mivel az osztály a Thread osztály kódját és a szálhoz rendelt feladatot tartalmazza	A Runnable interfész bevezetése laza csatlakozást vezet be, mivel a Thread kód különálló formában van a Threads munkájának.

A szálosztály meghatározása

A téma a java.lang csomag osztálya. A Thread osztály kiterjeszti az Objektumosztályt, és végrehajtja a Runnable interfészeket. A Thread osztálynak vannak konstruktorai és módszerei a szál létrehozására és működtetésére. Amikor több szálat hozunk létre, minden szál egyedi objektumot hoz létre, és hozzárendelhető az adott objektumhoz. Ha létrehoz egy szálat, amely kiterjeszti a szálosztályt, akkor nem lehet más osztályt kiterjeszteni, mivel a java nem támogatja a többszörös öröklést. Tehát csak akkor válassza ki, ha a Thread osztályt csak akkor kívánja kiterjeszteni, ha felülírja a Thread osztály néhány más módját is. Lássunk egy példát egy szál létrehozására, amely kiterjeszt egy szálosztályt.

 / * Menet definiálása * / Class Mythread kiterjeszti a szál {/ * jobját a * / public void run () {for (int i = 0; i <10; i ++) {System.Out.Println ("Gyermek téma" ); }} Osztály mainThread {/ * főfonal * / nyilvános statikus üreg fő (String args []) {Mythread mt = új Mythread (); / * a fő szál létrehozta a * / mt.start (); (int i = 0; i <10; i ++) {System.Out.Print ("Fő téma"); }}} / * Kimenet * / Fő téma Fő téma Fő téma Fő téma Gyermek Téma Gyermek Téma Gyermek Téma Gyermek Téma Fő téma Gyermek Téma Fő téma Fő téma Gyermek Téma Gyermek Téma Fő téma Fő téma Gyermek Téma Gyermek Téma Fő téma

A fenti kódban létrehozom a Mythread osztályt, amely kiterjeszti a Thread osztályt, és felülbírálja a Thread osztály futási módját. A fő módszert tartalmazó osztályban létrehozom a Mythread osztály szálobjektumát (mt), és a szálobjektum használatával a start () metódust használjuk. A start módszer elindítja a szál végrehajtását, és ezzel egyidejűleg a JVM meghívja a szál futtatási módját. Most két szál van a programban, egy fő szál és a második szál által létrehozott második szál. Mindkét szál végrehajtása egyszerre történik, de a pontos kimenet nem tehető.

A futtatható interfész meghatározása

A runnable egy interfész a java.lang csomagban. A Runnable interfész megvalósítása egy szál definiálható. A futtatható interfész egyetlen módszert futtat (), amelyet a Runnable interfészt megvalósító osztály hajt végre. Ha úgy dönt, hogy meghatározza a Runnable felületet megvalósító szálat, akkor még mindig választhat, hogy bármely más osztályt kiterjeszti. Amikor több szálat hoz létre a Runnable interfész alkalmazásával, minden egyes szál ugyanazt a futható példányt használja. tanuljunk meg, hogyan definiálhatunk egy szálat a Runnable felület segítségével.

 / * Menet definiálása * / Class Runnablethread végrehajtja a futó {/ * job * / public void run () {for (int i = 0; i <10; i ++) {System.Out.Println ("Gyermek téma" ); }} Osztály mainThread {/ * főfonal * / nyilvános statikus üreg fő (String args []) {Mythread rt = new Mythread (); / * a fő szál létrehozta a futható objektumot * / Téma t = új téma (rt); / * A fő szál gyermekszálat hoz létre, és átmegy a * / t.start (); (int i = 0; i <10; i ++) {System.Out.Print ("Fő téma"); }}} / * Kimenet * / Fő téma Fő téma Fő téma Fő téma Gyermek Téma Gyermek Téma Gyermek Téma Gyermek Téma Fő téma Gyermek Téma Fő téma Fő téma Gyermek Téma Gyermek Téma Fő téma Fő téma Gyermek Téma Gyermek Téma Fő téma

A fenti kódban létrehoztam egy Runnablethread osztályt, amely a Runnable interfészt implementálja, és meghatározza a szál munkáját a Runnable interfész futási () módszerének végrehajtásával. Ezután létrehozok egy osztályt, amely a fő módszert tartalmazza. A fő módszeren belül a Runnablethread osztály futható tárgyát nyilvánítottam, és ezt az objektumot átadtam a Thread konstruktorának, miközben egy szálat deklarált. Ily módon összekapcsoltam a szálobjektumot (t) egy futható objektummal (rt). Ezután a szálobjektum megkezdi a menet indítási módját, amely tovább rúgja a Runnablethread osztály futtatási módját. Ha nem voltam összekapcsolva a futó objektumot a Thread objektummal, akkor a szálak indítási módszere a Thread osztály futási módját használta volna. Most ismét a kódban két szál van, a fő szál és a fő szál gyermekszálat hoz létre, mindkettőt egyszerre hajtják végre, de a pontos kimenet soha nem tehető.

A szál és a futtatható Java kulcsfontosságú különbségei

A Thread osztály meghosszabbításával létrehozott minden szál egyedi objektumot hoz létre, és hozzárendelhető az adott objektumhoz. Másrészt, a Runnable interfész bevezetésével létrehozott szálak ugyanazt a futó példányt használják.
Mivel a szálosztály kiterjesztésével létrehozott egyes szálak egy egyedi objektumhoz kapcsolódnak, több memória szükséges. Másrészről, a Runnable interfész megvalósításával létrehozott szálak ugyanazt az objektumteret használják, ezért kevesebb memóriát igényel.
Ha tovább bővíti a szálosztályt, akkor bármely más osztályt örökölhet, mivel a Java nem engedélyezi a többszörös öröklést, míg a Runnable megvalósítása még egy esélyt ad egy osztálynak bármely más osztály örökölésére.
Egy szálosztályt csak akkor kell meghosszabbítani, ha felülírja vagy specializálhatja a Thread osztály más módszereit. Ha csak a futási módszerre szeretne specializálódni, végre kell hajtania egy Runnable felületet.
A Thread osztály kiterjesztése a kódban szoros csatlakozást vezet be, mivel a szál kódja és a szál munkája ugyanabban az osztályban található. Másrészről, a megvalósítható futófelület a kódban laza csatlakozást vezet be, mivel a szál kódja a szálhoz rendelt feladattól függ.

Következtetés:

Előnyös, ha a Menetes osztály kiterjesztése helyett Runnable interfészt alkalmazunk. Mivel a Runnable végrehajtása a kódot lazán összekapcsolja, mivel a szál kódja különbözik a szálhoz hozzárendelt osztálytól. Kevesebb memóriát igényel, és lehetővé teszi egy osztály számára, hogy más osztályt örököljen.