Nieuwe threads maken en starten

"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:

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

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."

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 .

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

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 :

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

}

"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?"

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() ."