"Hallo, Amigo! Ellie heeft je over threads verteld, en ik ga je vertellen hoe je ermee werkt. Om een ​​nieuwe thread te maken, moet je:"

1)  Maak een Thread-object

2) Geef het de methode door die u wilt uitvoeren

3)  Roep de startmethode aan op het gemaakte Thread-object.

Overweeg dit voorbeeld:

Code Beschrijving 
class Printer implements Runnable
{
public void run()
{
System.out.println("I’m printer");
}
}
 Klasse die de Runnable- interface implementeert. 
public static void main(String[] args)
{
Printer printer = new Printer();
Thread childThread = new Thread(printer);
childThread.start();
}
 1 Maak een instantie van de klasse Printer, die de run-methode implementeert.
2 Maak een nieuw Thread-object. We geven de constructor het printerobject door waarvan de methode run() moet worden aangeroepen.
3 Start de nieuwe thread door de methode start() aan te roepen .

Kleine Java-programma's bestaan ​​gewoonlijk uit één thread, de «hoofdthread» genoemd. Maar programma's lanceren vaker extra threads, die «child threads» worden genoemd. De hoofdthread voert de hoofdmethode uit en eindigt. De run- methode van de Runnable is de analoge methode voor onderliggende threads.

"Ah, veel threads betekent veel hoofdmethoden."

Nieuwe threads maken en starten - 1

Om een ​​Thread-object te vertellen welke specifieke methode het moet starten, moeten we er op de een of andere manier een methode aan doorgeven. In Java wordt dit gedaan met behulp van de Runnable- interface. Deze interface bevat een enkele abstracte methode: void run() . De klasse Thread heeft een constructor Thread (Runnable Runnable) . U kunt elk object doorgeven dat de Runnable- interface implementeert.

Uw klasse moet Runnable erven en de run -methode overschrijven. Het aanroepen van deze methode is wat de nieuwe thread start. Je kunt schrijven wat je wilt in de methode run .

Code Beschrijving 
class Printer implements Runnable
{
private String name;
public Printer(String name)
{
this.name = name;
}
public void run()
{
System.out.println("I’m " + this.name);
}
}
 Klasse die de Runnable-interface implementeert. 
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();
}
 Maak twee threads, die elk gebaseerd zijn op een eigen Printer-object. 
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();
}
 Maak drie threads op basis van een enkel printerobject.

Bovendien kun je dit allemaal combineren in één les. De Thread-klasse erft de Runnable-interface , dus u hoeft alleen de run-methode te overschrijven :

Een andere manier om een ​​nieuw draadje te maken 
class Printer extends Thread
{
private String name;
public Printer(String name)
{
this.name = name;
}
public void run()
{
System.out.println("I’m " + this.name);
}
}
 Neem de Thread- klasse over, die de Runnable- interface implementeert , en overschrijf vervolgens de run- methode. 
public static void main(String[] args)
{
Printer printer = new Printer("Jack");
printer.start();

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

}
 Maak twee threads, die elk gebaseerd zijn op een eigen Printer- object.

"Dit is een elegantere oplossing."

"Ja, maar het heeft zijn tekortkomingen:"

1)  Mogelijk moet u meerdere threads starten op basis van een enkel object, zoals in het voorbeeld met Natasha.

2)  Als u overerft van de klasse Thread, kunt u geen andere bovenliggende klasse aan uw klasse toevoegen.

3)  Als uw klasse een bovenliggende klasse heeft, kunt u Thread niet toevoegen als een tweede bovenliggende klasse.

"Met andere woorden, nadat de startmethode is aangeroepen, begint elk van de threads met het uitvoeren van de runmethode van het object dat aan de constructor is doorgegeven?"

"Ja. Als er niets aan de constructor wordt doorgegeven, voert Thread gewoon zijn interne run-methode uit."

"Maar waarom noemen we de methode niet gewoon zo?"

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

"Wanneer de hoofdthread de run- methode bereikt, gaat zijn "kleine robot" gewoon naar binnen en voert alle opdrachten erin uit. Pas nadat ze zijn uitgevoerd, keert het terug naar de hoofdmethode en gaat verder met het uitvoeren van verdere commando's. Dus geen tweede " kleine robot" zal worden gemaakt. Al het werk zal opeenvolgend worden uitgevoerd, niet parallel (gelijktijdig)."

'Ik snap het. Kun je een andere methode aanroepen, iets anders dan rennen?'

"Nee. Het is allemaal gekoppeld aan de Runnable-interface, die slechts één van zijn methoden "kent": run() ."

Java university