Új szálak létrehozása és indítása

"Szia, Amigo! Ellie mesélt neked a szálakról, én pedig el fogom mondani, hogyan dolgozol velük. Új szál létrehozásához a következőket kell tenned:"

1)  Hozzon létre egy Thread objektumot

2) Adja meg a futtatni kívánt metódust

3)  Hívja meg a start metódust a létrehozott Thread objektumon.

Tekintsük ezt a példát:

class Printer implements Runnable
{
public void run()
{
System.out.println("I’m printer");
}
}

public static void main(String[] args)
{
Printer printer = new Printer();
Thread childThread = new Thread(printer);
childThread.start();
}

A kis Java programok általában egy szálból állnak, amelyet "főszálnak" neveznek. De a programok gyakrabban indítanak el további szálakat, amelyeket „gyermekszálaknak” neveznek. A főszál a fő módszert futtatja és véget ér. A Runnable futtatási metódusa hasonló a gyermekszálakhoz.

"Ah, a sok szál sok fő módszert jelent."

Ahhoz, hogy a Thread objektumnak megmondhassuk, melyik metódusnak kell elindulnia, valahogy át kell adnunk neki egy metódust. Java-ban ez a Runnable felület segítségével történik . Ez a felület egyetlen absztrakt metódust tartalmaz: void run() . A Thread osztálynak van egy Thread(Runnable Runnable) konstruktora. Bármilyen objektumot átadhat, amely megvalósítja a Runnable felületet.

Az osztálynak örökölnie kell a Runnable-t , és felül kell írnia a futtatási metódust. Ennek a metódusnak a meghívása indítja el az új szálat. A run metódusban bármit írhatsz, amit akarsz .

class Printer implements Runnable
{
private String name;
public Printer(String name)
{
this.name = name;
}
public void run()
{
System.out.println("I’m " + this.name);
}
}

public static void main(String[] args)
{
Printer printer1 = new Printer("Nick");
Thread thread1 = new Thread(printer1);
thread1.start();

Printer printer2 = new Printer("Jack");
Thread thread2 = new Thread(printer2);
thread2.start();
}

public static void main(String[] args)
{
Printer printer = new Printer("Natasha");

Thread thread1 = new Thread(printer);
thread1.start();

Thread thread2 = new Thread(printer);
thread2.start();

Thread thread3 = new Thread(printer);
thread3.start();
}

Sőt, mindezt egy osztályba is egyesítheti. A Thread osztály a Runnable felületet örökli , így csak a futtatási metódusát kell felülírnia :

class Printer extends Thread
{
private String name;
public Printer(String name)
{
this.name = name;
}
public void run()
{
System.out.println("I’m " + this.name);
}
}

public static void main(String[] args)
{
Printer printer = new Printer("Jack");
printer.start();

Printer printer2 = new Printer("Jack");
printer2.start();

}

– Ez egy elegánsabb megoldás.

"Igen, de vannak hiányosságai:"

1)  Lehet, hogy több szálat kell indítania egyetlen objektum alapján, mint a Natasha példában.

2)  Ha a Thread osztályból örököl, nem adhat hozzá másik szülőosztályt az osztályhoz.

3)  Ha az osztályodnak van szülőosztálya, akkor nem adhatod hozzá a Szálat második szülőosztályként.

"Más szóval, a start metódus meghívása után mindegyik szál elkezdi végrehajtani a konstruktornak átadott objektum futtatási metódusát?"

"Igen. Ha semmit nem ad át a konstruktornak, akkor a Thread csak végrehajtja a belső futtatási metódust."

– De miért nem hívjuk így a módszert?

public static void main(String[] args)
{
 Printer printer1 = new Printer("Nick");
 printer1.run();
}

"Amikor a főszál eléri a futtatási metódust, a "kis robotja" egyszerűen bemegy, és végrehajtja a benne lévő összes parancsot. Csak azok végrehajtása után tér vissza a fő metódushoz, és folytatja a további parancsok végrehajtását. Így nincs második " kis robot" jön létre. Minden munka egymás után történik, nem párhuzamosan (egyidejűleg)."

– Értem. Tudsz más módszert hívni, valami mást, mint a futást?

"Nem. Mindez a Runnable felülethez van kötve, amely csak az egyik metódusáról "tud": run() ."