[Java] thread moet wachten op thread?

[Verwijderd]

Ik ben bezig met een java swing programma en start voor een lange taak een thread. Deze thread start vervolgens een andere thread. In pseudo code:

code:

function startlongtask(){
T1.start();
}


function T1.run(){
T2.start();
//wacht totdat T2 klaar is
print "Ikke klaar!";
}

function T2.run(){
dosomethinglong();
}

T1 en T2 zijn Threads. In Thread1 run methode word Thread2 gestart. Nu zou het ideaal zijn als T1 even stopt en wacht op T2 totdat deze klaar is.

Maar hoe kan ik dat het beste aanpakken, ik kan T1 T2 laten pollen en zo kijken of T2 klaar is. Ik kan ook T1 een Status interface laten implementeren en dan deze Status interface meegeven aan de T2 constructor, T2 roept dan de Klaar() functie van de Status interface aan.

Het zijn allemaal oplossingen die het doen, maar niet echt "mooi" zijn. Heeft java hier geen standaard oplossing voor?

[Speed24]

Semaforen zijn hier voor:

Google is your friend

Google again

[-FoX-]

Java heeft hier inderdaad reeds een oplossing voor. Laat je thread een method uitvoeren, en bepaal deze method als synchronized. Op die manier kan slechts 1 thread gelijkertijd die method gebruiken.

Met het keyword synchronized kom je wel een eindje verder denk ik

[momania]

Je standaard java oplossing is de method join()

Roep in de huidige thread de join() method aan van de thread die je net gestart hebt en de huidige thread gaat dan pas verder als de net opgestartte thread klaar is

Java:

class Thread1 implements Runnable {
  public void run() {
    try {
      Thread.sleep(1000);
      System.out.prinln("Thread1 klaar");
    }
    catch (InterruptedExceptin ie) {
      ie.printStackTrace();
    }
  } 
}
class Thread2 implements Runnable {
  public void run() {
    try {
      Thread.sleep(200);
      System.out.prinln("Thread2 klaar");
    }
    catch (InterruptedExceptin ie) {
      ie.printStackTrace();
    }
  } 
}
class ThreadTester {

  public void main(String[] args) {

      Thread1 t1 = new Thread1();
      Thread2 t2 = new Thread2();

      t1.start();
      t1.join();
      t2.start();
  }
}

Als je in deze code de regel met de join weg laat zal je zien dat Thread2 eerder klaar is dan Thread1.
Laat je de join call erin, dan zie je dat met het starten van Thread2 netjes wordt gewacht tot Thread1 klaar is.

Eventueel kan je aan de method join nog een timeout meegeven in ms.

[Verwijderd]

Dat join zie ik wel zitten momania, lekker simpel en het doet wat het moet doen. Vreemd dat ik die functie nog nooit heb gezien. Ik ga hem meteen uitproberen!

[momania]

Verwijderd schreef op 27 september 2004 @ 22:41:
Vreemd dat ik die functie nog nooit heb gezien.

Dan moet je de volgende keer toch even beter de API door lezen als je iets specifieks zoekt.

Je wilt iets met een Thread dus dan moet je hier beginnen met zoeken:
http://java.sun.com/j2se/1.3/docs/api/java/lang/Thread.html

[Verwijderd]

momania schreef op 27 september 2004 @ 23:02:
[...]

Dan moet je de volgende keer toch even beter de API door lezen als je iets specifieks zoekt.

Je wilt iets met een Thread dus dan moet je hier beginnen met zoeken:
http://java.sun.com/j2se/1.3/docs/api/java/lang/Thread.html

Klopt Een paar jaartjes terug heb ik met jdk1.02 en later nog wat met 1.1 gewerkt, dus m'n kennis van de api gaat maar tot 1.1 en een beetje van 1.1. Nu zit ik sinds jaren weer met swing te werken. Natuurlijk wel een swing opfris cursus gedaan, maar de java api is zo groot geworden dat je soms weleens een functie over het hoofd ziet.

Maar dat swing is wel verbetert zeg, ik ben nog maar 1 bug tegengekomen (als je een defaultcombobox model update die gebonden is aan een jcombobox word een itemstatechanged en een actionperformed event gegeneerd).

[Verwijderd]

momania schreef op 27 september 2004 @ 21:01:

Java:

class Thread1 implements Runnable {
  public void run() {
    try {
      Thread.sleep(1000);
      System.out.prinln("Thread1 klaar");
    }
    catch (InterruptedExceptin ie) {
      ie.printStackTrace();
    }
  } 
}
class Thread2 implements Runnable {
  public void run() {
    try {
      Thread.sleep(200);
      System.out.prinln("Thread2 klaar");
    }
    catch (InterruptedExceptin ie) {
      ie.printStackTrace();
    }
  } 
}
class ThreadTester {

  public void main(String[] args) {

      Thread1 t1 = new Thread1();
      Thread2 t2 = new Thread2();

      t1.start();
      t1.join();
      t1.start();
  }
}

op deze manier is t2 nogal zinloos

[momania]

Verwijderd schreef op 28 september 2004 @ 00:15:
[...]


op deze manier is t2 nogal zinloos

Want

Enige onderbouwing zou geen kwaad kunnen

[Verwijderd]

kijk eens in je main methode,
je initialiseert t2, maar later doe je er niets meer mee

tikfoutje?

[momania]

Ooh

Mja, 't idee was wel duidelijk toch?

[edit]
iig maar even gefixed

[ Voor 27% gewijzigd door momania op 28-09-2004 00:26 ]