Mielőtt bemutatná a szál koncepció , nem tudtunk egynél több feladatot párhuzamosan futtatni. Ez egy hátrány volt, és hogy ezt a hátrányt megszüntesse, Szál koncepció bemutatták.
A cérna egy nagyon kis súlyozású folyamat, vagy mondhatjuk a folyamat legkisebb része, amely lehetővé teszi a program hatékonyabb működését több feladat egyidejű futtatásával.
meghatározatlan lejtő
Ahhoz, hogy bonyolult feladatokat végezhessünk a háttérben, a Szál koncepció Java nyelven . Az összes feladat végrehajtása a főprogram befolyásolása nélkül történik. Egy programban vagy folyamatban minden szálnak megvan a maga külön útvonala a végrehajtáshoz, így a folyamat minden szála független.
A használat másik előnye cérna az, hogy ha egy szál kivételt vagy hibát kap a végrehajtása során, az nincs hatással a többi szál végrehajtására. Az összes szál közös memóriával rendelkezik, és saját veremük, helyi változói és programszámlálója van. Ha egyszerre több szálat hajtanak végre párhuzamosan, ezt a folyamatot úgy hívják Többszálú .
Egyszerű módon a szál a következő:
- Funkció, amelyen keresztül több tevékenységet végezhetünk egyetlen folyamaton belül.
- Könnyű eljárás.
- Végrehajtott utasítások sorozata.
- Metódushívások beágyazott sorozata.
Menetmodell
Csakúgy, mint egy folyamat, egy szál több állapotban is létezik. Ezek az állapotok a következők:
1) Új (futásra kész)
Benne van egy szál Új amikor megkapja a CPU-időt.
2) Futás
Benne van egy szál a Futás adja meg, hogy mikor van végrehajtás alatt.
3) Felfüggesztve
Egy szál van a Felfüggesztett azt az állapotot, amikor átmenetileg inaktív vagy végrehajtás alatt van.
4) Blokkolt
szelén alapjai
Egy szál van a Zárolt jelezze, hogy mikor vár forrásokra.
5) Megszűnt
Egy szál akkor kerül ebbe az állapotba, amikor egy adott időpontban azonnal leállítja a végrehajtását.
Szál létrehozása
A szál a 'létrehozásával vagy megvalósításával' jön létre Futtatható felület vagy kiterjesztésével a Szál osztály . Csak ezen a két módon hozhatunk létre szálat.
Nézzük meg a szál létrehozásának mindkét módját:
Szál osztály
A Szál osztály számos módszerrel és konstruktorral rendelkezik, amelyek lehetővé teszik, hogy különféle műveleteket hajtsunk végre egy szálon. A Thread osztály kiterjeszti a Tárgy osztály. A Tárgy osztály valósítja meg a Futható felület. A szálosztály a következő konstruktorokkal rendelkezik, amelyek különféle műveletek végrehajtására szolgálnak.
Futtatható felület (run() metódus)
A Runnable interfészt annak az osztálynak kell megvalósítania, amelynek példányait egy szál hajtja végre. A futtatható felület megadja nekünk a fuss() metódus a szál műveletének végrehajtására.
start() metódus
A módszer egy újonnan létrehozott szál indítására szolgál. Új szálat indít egy új callstack-el. Végrehajtása után a Rajt() módszerrel a szál állapotát Újról Futhatóra változtatja. Végrehajtja a run() metódus amikor a szál megkapja a megfelelő időpontot a végrehajtásához.
adatszerkezetek java-ban
Vegyünk egy példát, hogy megértsük, hogyan hozhatunk létre a Jáva szál a szál osztály kiterjesztésével:
ThreadExample1.java
// Implementing runnable interface by extending Thread class public class ThreadExample1 extends Thread { // run() method to perform action for thread. public void run() { int a= 10; int b=12; int result = a+b; System.out.println('Thread started running..'); System.out.println('Sum of two numbers is: '+ result); } public static void main( String args[] ) { // Creating instance of the class extend Thread class ThreadExample1 t1 = new ThreadExample1(); //calling start method to execute the run() method of the Thread class t1.start(); } } Kimenet:
Szál létrehozása a futtatható felület megvalósításával
Java-ban a futtatható felület megvalósításával is létrehozhatunk szálat. A futtatható felület biztosítja számunkra a run() és a start() metódust is.
Vegyünk egy példát, hogy megértsük, hogyan hozhatjuk létre, indíthatjuk el és futtathatjuk a szálat a futtatható felület segítségével.
ThreadExample2.java
class NewThread implements Runnable { String name; Thread thread; NewThread (String name){ this.name = name; thread = new Thread(this, name); System.out.println( 'A New thread: ' + thread+ 'is created
' ); thread.start(); } public void run() { try { for(int j = 5; j > 0; j--) { System.out.println(name + ': ' + j); Thread.sleep(1000); } }catch (InterruptedException e) { System.out.println(name + ' thread Interrupted'); } System.out.println(name + ' thread exiting.'); } } class ThreadExample2 { public static void main(String args[]) { new NewThread('1st'); new NewThread('2nd'); new NewThread('3rd'); try { Thread.sleep(8000); } catch (InterruptedException excetion) { System.out.println('Inturruption occurs in Main Thread'); } System.out.println('We are exiting from Main Thread'); } } Kimenet:
A fenti példában a Multithreading-et a futtatható felület megvalósításával hajtjuk végre. Ha többet szeretne megtudni a Multithreadingről, kattints ide .