wake-up-neo.com

Java Multithreading-Konzept und join () -Methode

Ich bin verwirrt in der join()-Methode, die in Threads in Java verwendet wird. Im folgenden Code:

// Using join() to wait for threads to finish.
class NewThread implements Runnable {

    String name; // name of thread
    Thread t;

    NewThread(String threadname) {
        name = threadname;
        t = new Thread(this, name);
        System.out.println("New thread: " + t);
        t.start(); // Start the thread
    }
// This is the entry point for thread.

    public void run() {
        try {
            for (int i = 5; i > 0; i--) {
                System.out.println(name + ": " + i);
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            System.out.println(name + " interrupted.");
        }
        System.out.println(name + " exiting.");
    }
}

class DemoJoin {

    public static void main(String args[]) {
        NewThread ob1 = new NewThread("One");
        NewThread ob2 = new NewThread("Two");
        NewThread ob3 = new NewThread("Three");
        System.out.println("Thread One is alive: "
                + ob1.t.isAlive());
        System.out.println("Thread Two is alive: "
                + ob2.t.isAlive());
        System.out.println("Thread Three is alive: "
                + ob3.t.isAlive());
// wait for threads to finish
        try {
            System.out.println("Waiting for threads to finish.");
            ob1.t.join();
            ob2.t.join();
            ob3.t.join();
        } catch (InterruptedException e) {
            System.out.println("Main thread Interrupted");
        }
        System.out.println("Thread One is alive: "
                + ob1.t.isAlive());
        System.out.println("Thread Two is alive: "
                + ob2.t.isAlive());
        System.out.println("Thread Three is alive: "
                + ob3.t.isAlive());
        System.out.println("Main thread exiting.");
    }
}

Die Beispielausgabe dieses Programms wird hier gezeigt:

New thread: Thread[One,5,main]
New thread: Thread[Two,5,main]
New thread: Thread[Three,5,main]
Thread One is alive: true
Thread Two is alive: true
Thread Three is alive: true
Waiting for threads to finish.
One: 5
Two: 5
Three: 5
One: 4
Two: 4
Three: 4
One: 3
Two: 3
Three: 3
One: 2
Two: 2
Three: 2
One: 1
Two: 1
Three: 1
Two exiting.
Three exiting.
One exiting.
Thread One is alive: false
Thread Two is alive: false
Thread Three is alive: false
Main thread Exiting

Im obigen Code:

  1. Ich bin nicht in der Lage, den Ablauf der Programmausführung zu verstehen. Wenn ob1 erstellt wird, wird der Konstruktor aufgerufen, in dem t.start() geschrieben ist, aber die run()-Methode wird nicht ausgeführt, sondern die main()-Methode setzt die Ausführung fort. Warum passiert das?

  2. Die join()-Methode wird verwendet, um zu warten, bis der Thread, auf dem sie aufgerufen wird, nicht beendet wird, aber hier in der Ausgabe sehen wir alternative Ausgaben des Threads, warum ??

Und wenn die Verwendung von join das ist, was ist die Verwendung von synchronized?

Ich weiß, dass mir hier ein grundlegendes Konzept fehlt, aber ich kann es nicht herausfinden, also helfen Sie bitte.

54
user2696258

Sie müssen wissen, dass die Thread-Planung durch den Thread-Scheduler gesteuert wird. Daher können Sie die Reihenfolge der Threads unter normalen Umständen nicht garantieren.

Sie können jedoch mit join() warten, bis ein Thread seine Arbeit abgeschlossen hat.

Zum Beispiel in Ihrem Fall

ob1.t.join();

Diese Anweisung wird erst zurückgegeben, wenn der Thread t beendet ist.

Versuche dies,

class Demo {
   Thread t = new Thread(
                 new Runnable() {
                     public void run () {
                         //do something
                     }
                  }
    );
    Thread t1 = new Thread(
                 new Runnable() {
                     public void run () {
                         //do something
                     }
                  }
    );
    t.start(); // Line 15
    t.join();  // Line 16
    t1.start();
}

Im obigen Beispiel wird Ihr Haupt-Thread ausgeführt. Wenn er auf Zeile 15 trifft, ist Thread t im Thread-Scheduler verfügbar. Sobald der Haupt-Thread die Zeile 16 erreicht, wartet er, bis der Thread t beendet ist.

Beachten Sie, dass t.join nichts zum Thread t oder zum Thread t1 unternommen hat. Es betrifft nur den Thread, der es aufgerufen hat (d. H. Den main()-Thread).

bearbeitet:

t.join(); muss sich innerhalb des try-Blocks befinden, da es throws die InterruptedException-Ausnahme ist. Andernfalls wird beim Kompilieren ein Fehler angezeigt. So sollte es sein:

try{
    t.join();
}catch(InterruptedException e){
    // ...
}
151
Malwaregeek

Wenn Sie ob1 erstellen, wird der Konstruktor aufgerufen, und er beginnt mit der Ausführung. Zu diesem Zeitpunkt läuft t.start() auch in einem separaten Thread. Denken Sie daran, wenn ein neuer Thread erstellt wird, läuft er parallel zum Haupt-Thread. Deshalb starten Sie mit der nächsten Anweisung erneut mit der Ausführung. 

Die Join()-Anweisung wird mit verwendet, um zu verhindern, dass der untergeordnete Thread verwaist wird. Bedeutet, wenn Sie join() in Ihrer Hauptklasse nicht aufgerufen haben, wird der Haupt-Thread nach dessen Ausführung beendet, und der untergeordnete Thread wird immer noch die Anweisungen ausführen. Join() wartet, bis die Ausführung aller untergeordneten Threads abgeschlossen ist, und nur die Hauptmethode wird beendet.

Gehen Sie durch this article, hilft viel.

4
Vimal Bera

Ich kann den Ablauf der Ausführung des Programms nicht verstehen. Wenn ob1 erstellt wird, wird der Konstruktor aufgerufen, in dem t.start () geschrieben wird, aber die Methode run () nicht ausgeführt wird. Die Methode main () setzt die Ausführung jedoch fort. Warum passiert das?

Dies hängt vom Thread-Scheduler ab, da main dieselbe Prioritätsreihenfolge hat. Das Aufrufen von start () bedeutet nicht, dass run () sofort aufgerufen wird. Es hängt vom Thread-Scheduler ab, wenn es sich für die Ausführung des Threads entscheidet. 

die join () -Methode wird verwendet, um zu warten, bis der Thread, für den sie aufgerufen wird, nicht beendet wird, aber hier in der Ausgabe sehen wir alternative Ausgaben des Threads, warum ??

Dies liegt an der Thread.sleep (1000) in Ihrem Code. Entfernen Sie diese Zeile und sehen Sie ob1 endet vor ob2, die wiederum vor ob3 endet (wie erwartet mit join ()). Allerdings hängt das alles davon ab, wann ob1 ob2 und ob3 begonnen haben. Durch das Aufrufen von sleep wird die Ausführung des Threads für> = 1 Sekunde (in Ihrem Code) angehalten. Dies gibt dem Scheduler die Möglichkeit, andere wartende Threads (gleiche Priorität) aufzurufen.

3
rmishra

Erste Regel beim Einfädeln - "Einfädeln macht Spaß" ...

Ich kann den Ablauf der Ausführung des Programms nicht verstehen, und Wenn ob1 erstellt wird, wird der Konstruktor aufgerufen, wobei t.start() .__ ist. geschrieben, aber die run()-Methode wird nicht ausgeführt, sondern die main()-Methode setzt die Ausführung fort. Warum passiert das?

Genau das sollte passieren. Wenn Sie Thread#start aufrufen, wird der Thread erstellt und für die Ausführung geplant. Er kann sofort (oder nahe genug) auftreten, möglicherweise nicht. Es kommt auf den Thread-Scheduler an.

Dies hängt davon ab, wie die Thread-Ausführung geplant ist und was sonst noch im System abläuft. Normalerweise wird jedem Thread eine kurze Zeit zur Ausführung eingeräumt, bevor er wieder in den "Ruhezustand" versetzt wird, und ein anderer Thread darf ausgeführt werden (offensichtlich können in mehreren Prozessorumgebungen mehrere Threads gleichzeitig ausgeführt werden. Versuchen wir es jedoch und mach es einfach;))

Threads können auch yield ausgeführt werden, sodass andere Threads im System die Möglichkeit haben, ausgeführt zu werden.

Du könntest es versuchen

NewThread(String threadname) {
    name = threadname;
    t = new Thread(this, name);
    System.out.println("New thread: " + t);
    t.start(); // Start the thread
    // Yield here
    Thread.yield();
}

Und es kann einen Unterschied machen, wie die Threads laufen. Gleichermaßen können Sie sleep für eine kurze Zeitspanne __ ändern, aber dies kann dazu führen, dass Ihr Thread für die Ausführung für einen Zyklus von Zyklen übersehen wird (manchmal möchten Sie dies manchmal Sie nicht ...

Die join()-Methode wird verwendet, um auf den Thread zu warten, für den sie aufgerufen wird endet nicht, aber hier in der Ausgabe sehen wir alternative Ausgaben von der Thread warum?

Die Art und Weise, wie Sie gesagt haben, die Frage sei falsch ... join wartet, bis die Thread beendet ist, bevor sie zurückkehrt. Wenn Sie beispielsweise abhängig vom Ergebnis einer Thread sind, können Sie join verwenden, um zu wissen, wann die Thread beendet ist, bevor Sie versuchen, das Ergebnis abzurufen.

Ebenso könnte man den Thread abfragen, aber dies würde CPU-Zyklen beanspruchen, die stattdessen besser von der Variablen Thread verwendet werden könnten ...

1
MadProgrammer

Ich bin auf den Join () gestoßen, als ich etwas über die Rennbedingungen erfuhr, und ich werde meine Zweifel klären. Nehmen wir dieses kleine Beispiel 

Thread t2 = new Thread(
             new Runnable() {
                 public void run () {
                     //do something
                 }
              }
);
Thread t1 = new Thread(
             new Runnable() {
                 public void run () {
                     //do something
                 }
              }
);
t2.start(); //Line 11
t1.start(); //Line 12
t2.join();  //Line 13
t1.join();  //Line 14
System.out.print("<Want to print something that was being modified by t2 and t1>")

Mein AIM
Drei Threads laufen, nämlich t1, t2 und der Hauptthread. Ich möchte etwas drucken, nachdem t1 und t2 beendet sind. Der Druckvorgang befindet sich in meinem Hauptthread. Daher muss ich für die erwartete Antwort t1 und t2 beenden und dann meine Ausgabe drucken.

T1.join () lässt also nur den Haupt-Thread warten, bis der Thread t1 abgeschlossen ist, bevor er zur nächsten Zeile im Programm wechselt. 

Hier ist die Definition gemäß GeeksforGeeks :

Die Java.lang.Thread-Klasse stellt die join () -Methode bereit, die eine .__ zulässt. Thread, der gewartet werden soll, bis ein anderer Thread seine Ausführung abgeschlossen hat.

Hier ist eine Frage, die Ihre Zweifel lösen könnte

Q-> Erhält t1-Thread die Zeitscheibe, die vom Thread-Scheduler ausgeführt werden soll, wenn das Programm t2.join () unter Line .__ verarbeitet. 13?

ANS-> Ja, es ist berechtigt, die Zeitscheibe zum Laufen zu bringen, da wir sie bereits durch die Zeile t1.start () unter Line. 11
t2.join () wendet nur die Bedingung an, wenn die JVM gestartet wird zur nächsten Zeile, das ist Zeile 14.
Es kann auch sein, dass t1 Die Verarbeitung könnte bei Zeile 13 beendet werden.

1
royatirek

Die JVM und das zugrunde liegende Betriebssystem haben bei der Planung der Dinge erhebliche Freiheit. Die Tatsache, dass Sie den gesamten Weg zu "Warten auf Threads bis zum Abschluss" erhalten, bevor Sie die Ausgabe einzelner Threads sehen, kann einfach bedeuten, dass der Start des Threads etwas länger dauert (dh es dauert eine Weile, bis ein Thread einen Thread erhält. lebendig "und wenn die run () - Methode tatsächlich ausgeführt wird). Es ist denkbar, dass Sie die Thread-Ausgabe früher sehen können, aber in beiden Fällen ist dies nicht garantiert.

Für join () garantiert es nur, dass alles, was danach kommt, erst dann geschieht, wenn der Thread, dem Sie beitreten, fertig ist. Wenn Sie also drei join () - Aufrufe in einer Reihe haben, heißt das nicht, dass die Threads in einer bestimmten Reihenfolge enden sollten. Es bedeutet einfach, dass Sie zuerst auf ob1 warten. Sobald ob1 fertig ist, können ob2 und ob3 noch laufen oder sie sind bereits fertig. Wenn sie fertig sind, werden Ihre anderen join () - Anrufe sofort zurückgegeben.

synchronized wird speziell verwendet, wenn mehrere Threads auf dasselbe Objekt zugreifen und Änderungen daran vornehmen. Es wird garantiert, dass ein synchronisierter Block niemals von zwei Threads gleichzeitig ausgeführt wird - d. H. Der Thread, der ihn ausführt, hat das synchronisierte Objekt ganz für sich.

1
codingjourney

wenn ob1 erstellt wird, wird der Konstruktor aufgerufen, in dem "t.start ()" geschrieben wird, die run () - Methode jedoch nicht ausgeführt wird. Die main () - Methode wird weiter ausgeführt. Warum passiert das?

hier haben Ihre Threads und Ihr Haupt-Thread die gleiche Priorität. Die Ausführung eines Threads mit gleicher Priorität hängt vollständig vom Thread schedular ab. Sie können nicht erwarten, welcher Schritt zuerst ausgeführt wird.

die join () -Methode wird verwendet, um zu warten, bis der Thread, für den sie aufgerufen wird, nicht beendet wird, aber hier in der Ausgabe sehen wir alternative Ausgaben des Threads, warum ??

Hier ihre aufrufenden Aussagen aus dem Hauptthread. 

     ob1.t.join();
     ob2.t.join();
     ob3.t.join();

Der Hauptthread wartet also darauf, dass ob1.t, ob2.t, ob3.t-Threads sterben (siehe Thread # join doc ). Alle drei Threads werden erfolgreich ausgeführt, und der Haupt-Thread wird danach abgeschlossen

1
Prabhaker

Der Thread-Scheduler ist für die Planung von Threads verantwortlich. Jedes Mal, wenn Sie das Programm ausführen, gibt es keine Garantie für die Reihenfolge der Ausführung von Threads. Angenommen, Sie haben ein Thread-Objekt namens threadOne, und wenn join () wie folgt auf threadOne aufgerufen wird:

threadOne.join ()

dann werden alle derzeit ausgeführten Threads angehalten, bis Thread1 seine Ausführung beendet hat oder beendet ist. 

Betrachten Sie den folgenden Code:

class RunnableSample implements Runnable {
    private Thread t;
    private String threadName;

    public RunnableSample(String name) {
        this.threadName = name;
    }
    public void run() {
        try {
            for(int i = 4; i >= 1; i--) {
                System.out.println(Thread.currentThread().getName() + ", " + i);
            Thread.sleep(500);
            }
        } catch (InterruptedException e) {
            System.out.println(threadName + " interrupted");
        }
    }
    public void start() {
        if(t == null)
            t = new Thread(this, threadName);
        t.start();
        try {
            t.join();
        } catch(Exception e) {
            System.out.println(e);
        }
    }
}
public class RunnableDemo {
    public static void main(String[] args) {
        RunnableSample r1 = new RunnableSample("threadOne");
        r1.start();

        RunnableSample r2 = new RunnableSample("threadTwo");
        r2.start();

        RunnableSample r3 = new RunnableSample("threadThree");
        r3.start();
     }
}

Die Ausgabe des obigen Programms wird sein:

threadOne, 4
threadOne, 3
threadOne, 2
threadOne, 1
threadTwo, 4
threadTwo, 3
threadTwo, 2
threadTwo, 1
threadThree, 4
threadThree, 3
threadThree, 2
threadThree, 1

Da join () zuerst für threadOne aufgerufen wird, werden threadTwo und threadThree angehalten, bis threadOne beendet wird. (Beachten Sie, dass threadOne, threadTwo und ThreadThree alle gestartet sind). Jetzt werden die Threads in einer bestimmten Reihenfolge ausgeführt. Wenn join () in unserem Beispiel nicht für einen Thread aufgerufen wird, gibt es keine Reihenfolge für die Ausführung von Threads.

public void start() {
    if(t == null)
        t = new Thread(this, threadName);
    t.start();
}

Seine Ausgabe wird sein:

threadOne, 4
threadThree, 4
threadTwo, 4
threadTwo, 3
threadThree, 3
threadOne, 3
threadOne, 2
threadThree, 2
threadTwo, 2
threadOne, 1
threadThree, 1
threadTwo, 1

Kommen Sie zur Synchronisierung. Dies ist nützlich, wenn Sie den Zugriff mehrerer Threads auf eine gemeinsam genutzte Ressource steuern möchten. Wenn Sie nur einen Thread für den Zugriff auf gemeinsam genutzte Ressourcen einschränken möchten, ist die Synchronisierung die beste Methode. 

1
Saathvik

Keine Wörter, die nur Code ausführen 

// Thread class
public class MyThread extends Thread {

    String result = null;

    public MyThread(String name) {
        super(name);
    }

    public void run() {
        for (int i = 0; i < 1000; i++) {

            System.out.println("Hello from " + this.getName());
        }
        result = "Bye from " + this.getName();
    }
}

Hauptklasse

public class JoinRND {
    public static void main(String[] args) {

        System.out.println("Show time");
        // Creating threads
        MyThread m1 = new MyThread("Thread M1");
        MyThread m2 = new MyThread("Thread M2");
        MyThread m3 = new MyThread("Thread M3");

        // Starting out Threads
        m1.start();
        m2.start();
        m3.start();
        // Just checking current value of thread class variable
        System.out.println("M1 before: " + m1.result);
        System.out.println("M2 before: " + m2.result);
        System.out.println("M3 before: " + m3.result);
        // After starting all threads main is performing its own logic in
        // parallel to other threads
        for (int i = 0; i < 1000; i++) {

            System.out.println("Hello from Main");
        }

        try {

            System.out
                    .println("Main is waiting for other threads to get there task completed");
            m1.join();
            m2.join();
            m3.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println("M1 after" + m1.result);
        System.out.println("M2 after" + m2.result);
        System.out.println("M3 after" + m3.result);

        System.out.println("Show over");
    }
}
1
Vijay Tyagi

Meine Kommentare:

Wenn ich die Ausgabe sehe, wird die Ausgabe mit Eins, Zwei, Drei gemischt, wobei es sich um die Threadnamen handelt, die gleichzeitig ausgeführt werden. Ich bin nicht sicher, ob Sie sagen, dass der Thread nicht mit der Hauptmethode ausgeführt wird.

Nicht sicher, ob ich deine Frage verstanden habe oder nicht. Aber ich stelle meine Antwort auf das, was ich verstehen könnte, hoffe, es kann Ihnen helfen.

1) Dann erstellten Sie das Objekt, das als Konstruktor bezeichnet wurde. In construct hat es eine Startmethode, die den Thread gestartet und den Inhalt ausgeführt hat, der innerhalb der run () - Methode geschrieben wurde. 

Wenn Sie also 3 Objekte (3 Threads - 1, 2, 3) erstellt haben, wurden alle 3 Threads gleichzeitig ausgeführt.

2) Join and Synchronization (Synchronisieren und Verbinden). Dies sind zwei verschiedene Aspekte. Synchronisierung ist, wenn mehrere Threads eine gemeinsame Ressource gemeinsam nutzen und ein Thread diese Ressource gleichzeitig verwenden sollte. Z.B. Threads wie DepositThread, WithdrawThread usw. verwenden ein gemeinsames Objekt als BankObject. Während DepositThread läuft, wartet das WithdrawThread, wenn sie synchronisiert sind. wait (), notify (), notifyAll () werden für die Kommunikation zwischen Threads verwendet. Plz google um mehr zu erfahren.

bei Join () handelt es sich um mehrere Threads, die jedoch zusammengeführt werden. z.B. Wenn zwei Threads t1 und t2 vorhanden sind und in einer Umgebung mit mehreren Threads ausgeführt werden, lautet die Ausgabe: t1-0 t2-0 t1-1 t2-1 t1 -2 T2-2

und wir verwenden t1.join (), das wäre: t1-0 t1-1 t1-2 t2-0 t2-1 t2-2

Dies wird in Echtzeit verwendet, wenn Sie den Thread unter bestimmten Umständen manchmal nicht verwechseln und einer anderen davon abhängt (nicht in einer gemeinsam genutzten Ressource), sodass Sie die join () -Methode aufrufen können.

1
user1460153

join () ist eine Instanzmethode der Java.lang.Thread-Klasse, mit der wir die join () -Methode verwenden können, um sicherzustellen, dass alle Threads, die von main gestartet wurden, in der Reihenfolge enden müssen, in der sie gestartet wurden, und auch main als letztes enden sollte. Mit anderen Worten, wartet, bis dieser Thread stirbt.

Ausnahme: Die Methode Join () löst InterruptedException aus.

Thread-Status: Wenn die join () -Methode für Thread aufgerufen wird, wird sie in den Wartezustand versetzt. Und warten, bis der Thread stirbt.

synchronized block: Der Thread muss vor dem Aufruf der join () - Methode keine Objektsperre erwerben, d. h. die join () - Methode kann von außerhalb des synchronisierten Blocks aufgerufen werden.

Wartezeit: Join (): Wartet darauf, dass dieser Thread stirbt.

public final void join() throws InterruptedException;

Diese Methode ruft intern join (0) auf. Und Timeout von 0 bedeutet für immer zu warten;

join (long Millis) - synchronisierte Methode Wartet höchstens Millisekunden, bis der Thread stirbt. Ein Timeout von 0 bedeutet für immer warten.

public final synchronized void join(long millis)
    throws InterruptedException;

public final synchronized void join(long millis, int nanos)
    throws InterruptedException;

Beispiel für eine Join-Methode

class MyThread implements Runnable {
     public void run() {
           String threadName = Thread.currentThread().getName();
           Printer.print("run() method of "+threadName);
           for(int i=0;i<4;i++){
                Printer.print("i="+i+" ,Thread="+threadName);
           }         
     }
}

public class TestJoin {
     public static void main(String...args) throws InterruptedException {
           Printer.print("start main()...");

           MyThread runnable = new MyThread();
           Thread thread1=new Thread(runnable);
           Thread thread2=new Thread(runnable);

           thread1.start();
           thread1.join();

           thread2.start();
           thread2.join();

           Printer.print("end main()");
     }
}

class Printer {
     public static void print(String str) {
           System.out.println(str);
     }
}

Output:
     start main()...
     run() method of Thread-0
     i=0 ,Thread=Thread-0
     i=1 ,Thread=Thread-0
     i=2 ,Thread=Thread-0
     i=3 ,Thread=Thread-0
     run() method of Thread-1
     i=0 ,Thread=Thread-1
     i=1 ,Thread=Thread-1
     i=2 ,Thread=Thread-1
     i=3 ,Thread=Thread-1
     end main()

Hinweis: Durch den Aufruf von Thread1.join () wurde der Haupt-Thread gewartet, bis Thread-1 stirbt.

Schauen wir uns ein Programm an, um join (long millis) zu verwenden.

Zuerst wird join (1000) in Thread-1 aufgerufen. Sobald jedoch 1000 Millisekunden aktiv sind, kann der Haupt-Thread den Thread2 wieder aufnehmen und starten (der Haupt-Thread wartet nicht auf den Abbruch von Thread-1).

class MyThread implements Runnable {
     public void run() {
           String threadName = Thread.currentThread().getName();
           Printer.print("run() method of "+threadName);
           for(int i=0;i<4;i++){
                try {
                     Thread.sleep(500);
                } catch (InterruptedException e) {
                     e.printStackTrace();
                }
                Printer.print("i="+i+" ,Thread="+threadName);
           }         
     }
}

public class TestJoin {
     public static void main(String...args) throws InterruptedException {
           Printer.print("start main()...");

           MyThread runnable = new MyThread();
           Thread thread1=new Thread(runnable);
           Thread thread2=new Thread(runnable);

           thread1.start();

           // once 1000 millisec are up,
           // main thread can resume and start thread2.
           thread1.join(1000);

           thread2.start();
           thread2.join();

           Printer.print("end main()");
     }
}

class Printer {
     public static void print(String str) {
           System.out.println(str);
     }
}

Output:
     start main()...
     run() method of Thread-0
     i=0 ,Thread=Thread-0
     run() method of Thread-1
     i=1 ,Thread=Thread-0
     i=2 ,Thread=Thread-0
     i=0 ,Thread=Thread-1
     i=1 ,Thread=Thread-1
     i=3 ,Thread=Thread-0
     i=2 ,Thread=Thread-1
     i=3 ,Thread=Thread-1
     end main()

Weitere Informationen finden Sie in meinem Blog:

http://javaexplorer03.blogspot.in/2016/05/join-method-in-Java.html

0
Rajesh Dixit

Das Konzept ist sehr einfach.

1) Alle Threads werden im Konstruktor gestartet und sind somit betriebsbereit. Main ist bereits der laufende Thread.

2) Nun haben Sie die t1.join () aufgerufen. Hier passiert, dass der Hauptfaden hinter dem T1-Faden geknotet wird. Sie können sich also einen längeren Thread mit main am unteren Ende von t1 vorstellen.

3) Nun gibt es drei Threads, die laufen könnten: t2, t3 und kombinierter Thread (t1 + main).

4) Nun, da t1 beendet ist, kann main nicht mehr laufen. Die Ausführung der beiden anderen Join-Anweisungen wurde gestoppt.

5) Der Scheduler entscheidet nun, welcher der oben genannten Threads (in Punkt 3) ausgeführt wird, was die Ausgabe erklärt.

0
ayush jain