Crearea și lansarea de noi fire

"Bună, Amigo! Ellie ți-a spus despre fire și o să-ți spun cum lucrezi cu ele. Pentru a crea un nou thread, trebuie să:"

1)  Creați un obiect Thread

2) Transmite-i metoda pe care vrei să o rulezi

3)  Apelați metoda de pornire pe obiectul Thread creat.

Luați în considerare acest exemplu:

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();
}

Programele Java mici constau de obicei dintr-un fir numit „fir principal”. Dar programele lansează mai des fire suplimentare, care se numesc „fire copii”. Firul principal rulează metoda principală și se termină. Metoda run a Runnable este metoda analogă pentru firele de execuție copii.

„Ah, o mulțime de fire înseamnă o mulțime de metode principale.”

Pentru a spune unui obiect Thread ce metodă specifică ar trebui să înceapă, trebuie să îi transmitem cumva o metodă. În Java, acest lucru se face folosind interfața Runnable . Această interfață conține o singură metodă abstractă: void run() . Clasa Thread are un constructor Thread(Runnable Runnable) . Puteți trece orice obiect care implementează interfața Runnable .

Clasa ta trebuie să moștenească Runnable și să-și suprascrie metoda de rulare . Invocarea acestei metode este ceea ce pornește noul thread. Puteți scrie orice doriți în metoda run .

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();
}

În plus, puteți combina toate acestea într-o singură clasă. Clasa Thread moștenește interfața Runnable , așa că trebuie doar să suprascriiți metoda de rulare a acesteia :

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();

}

„Aceasta este o soluție mai elegantă”.

„Da, dar are neajunsurile ei:”

1)  Poate fi necesar să începeți mai multe fire bazate pe un singur obiect, ca în exemplul cu Natasha.

2)  Dacă moșteniți din clasa Thread, nu puteți adăuga o altă clasă părinte la clasa dvs.

3)  Dacă clasa dvs. are o clasă părinte, nu puteți adăuga Thread ca a doua clasă părinte.

"Cu alte cuvinte, după ce metoda de pornire este apelată, fiecare dintre firele de execuție începe să execute metoda de rulare a obiectului transmis constructorului?"

"Da. Dacă nu se transmite nimic constructorului, atunci Thread doar execută metoda de rulare internă."

— Dar de ce nu numim metoda așa?

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

„Când firul principal ajunge la metoda de rulare , „micul robot” al său intră pur și simplu înăuntru și execută toate comenzile din interiorul său. Numai după ce acestea sunt executate va reveni la metoda principală și va continua executarea comenzilor suplimentare. Astfel, nicio secundă „ robot mic" va fi creat. Toate lucrările vor fi efectuate secvenţial, nu în paralel (simultan)."

— Înțeleg. Poți apela la o altă metodă, altceva decât să alergi?

„Nu. Totul este legat de interfața Runnable, care „știe” doar una dintre metodele sale: run() ”.