Oprettelse og start af nye tråde

"Hej, Amigo! Ellie fortalte dig om tråde, og jeg vil fortælle dig, hvordan du arbejder med dem. For at oprette en ny tråd skal du:"

1)  Opret et trådobjekt

2) Send den metode, du vil køre

3)  Kald startmetoden på det oprettede trådobjekt.

Overvej dette eksempel:

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

Små Java-programmer består normalt af én tråd kaldet «hovedtråden». Men programmer starter oftere yderligere tråde, som kaldes «barnetråde». Hovedtråden kører hovedmetoden og slutter. Runnable -metoden er den analoge metode til undertråde .

"Åh, masser af tråde betyder mange hovedmetoder."

For at fortælle et Thread-objekt, hvilken specifik metode det skal starte, skal vi på en eller anden måde videregive en metode til det. I Java gøres dette ved hjælp af Runnable- grænsefladen. Denne grænseflade indeholder en enkelt abstrakt metode: void run() . Thread-klassen har en Thread(Runnable Runnable) -konstruktør. Du kan sende ethvert objekt ind, der implementerer Runnable- grænsefladen.

Din klasse skal arve Runnable og tilsidesætte dens kørselsmetode . Påkaldelse af denne metode er det, der starter den nye tråd. Du kan skrive hvad du vil i kørselsmetoden .

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

Hvad mere er, kan du kombinere det hele i én klasse. Thread-klassen arver den Runnable-grænseflade , så du behøver kun at tilsidesætte dens kørselsmetode:

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

}

"Dette er en mere elegant løsning."

"Ja, men det har sine mangler:"

1)  Du skal muligvis starte flere tråde baseret på et enkelt objekt, som i eksemplet med Natasha.

2)  Hvis du arver fra Thread-klassen, kan du ikke tilføje en anden forældreklasse til din klasse.

3)  Hvis din klasse har en forældreklasse, kan du ikke tilføje Thread som en anden forældreklasse.

"Med andre ord, efter startmetoden er kaldt, begynder hver af trådene at udføre kørselsmetoden for objektet, der er sendt til konstruktøren?"

"Ja. Hvis intet sendes til konstruktøren, så udfører Thread bare sin interne kørselsmetode."

"Men hvorfor kalder vi ikke metoden sådan?"

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

"Når hovedtråden når kørselsmetoden , går dens "lille robot" ganske enkelt ind og udfører alle kommandoerne inde i den. Først efter at de er udført, vil den vende tilbage til hovedmetoden og fortsætte med at udføre yderligere kommandoer. Så ingen sekund " lille robot" vil blive oprettet. Alt arbejdet vil blive udført sekventielt, ikke parallelt (samtidigt)."

"Jeg kan se. Kan du kalde en anden metode, noget andet end at løbe?"

"Nej. Det hele er bundet til Runnable-grænsefladen, som kun "kender" om en af ​​dens metoder: run() ."