[Java] Joins en threadGroups

[Waster]

Ik heb problemen met joins en threadgroups. Ik moet 10 verschillende computerspelers een potje reversi laten spelen tegen 10 andere computerspelers. Hierdoor heb ik 100 verschillende partijen. Omdat ik verschillende van dit soort toernooitjes moet laten spelen wil ik dit optimaliseren met threads. Ik maak voor iedere partij een thread aan. Dit kan makkelijk, want de partijen hebben geen enkele informatie van elkaar nodig. Ik merk zelfs op een singlecore processor dat het sneller gaat, maar het is vooral de bedoeling om snelheidswinst te behalen op dualcores (en die heb ik tijdelijk niet). Na deze 100 threads moet alles weer gelijk lopen. Ik moet de punten enzo uitrekenen en dat kan pas als alle partijen zijn afgelopen. Op zich kun je met join op een thread wachten tot deze klaar is voordat de rest van de code wordt uitgevoerd. Ik heb echter 100 threads die wel allemaal door elkaar mogen lopen, maar er kan pas verder gegaan worden als ze allemaal klaar zijn. Ik dacht daarom dat een threadgroup de enige oplossing is. Ik doe al deze threads in een threadgroup, die op zijn beurt ook een thread is. Op deze thread kan dan wel afzonderlijk gewacht worden. Echter kan ik heel weinig vinden op het internet over threadgroups en het wil dan ook niet lukken. Mijn code:

Dit is mijn code waar de verkeerde volgorde wordt uitgevoerd:

Java:

Thread[]
threadList;
threadList = new Thread[100];

int t=0;
for(Speler z: zwartSpelers){
    for(Speler w: witSpelers){
        SpelThread s = new SpelThread(z, w, generatie);
        threadList[t] = new Thread(s);
        threadList[t].start();
        t++;
    }
}
        
System.out.println("end");

Levert op:

code:

end
Partij 1
Partij 2
.
.
.
enz.

En ik wil natuurlijk dat er het volgende gebeurt.

code:

Partij 1
Partij 2
.
.
.
Partij 99
Partij 100
end

End mag pas worden weergegeven als alle partijen die gespeeld worden in SpelThread zijn uitgevoerd. Ik dacht het volgende met ThreadGroup maar het werkt niet:

Java:

Thread[] threadList;
ThreadGroup threadGroup;
threadList = new Thread[100];
threadGroup = new ThreadGroup("toernooi");

int t=0;
for(Speler z: zwartSpelers){
    for(Speler w: witSpelers){
        SpelThread s = new SpelThread(z, w, generatie);
        threadList[t] = new Thread(threadGroup, s);
        threadList[t].start();
        t++;
    }
}

Thread toernooi = new Thread(threadGroup, "naam");
toernooi.start();
try{toernooi.join();}catch(Exception e){}
System.out.println("end");

En dit levert dezelfde uitvoer op als in mijn eerdere code. Wat doe ik verkeerd?

[Macros]

Ik denk dat je beter naar executors en futures kan kijken om je probleem op te lossen. Ipv Threads en Threadgroups. Een executor (geconfigureerd met een instelbaar aantal threads) kan dan al je games laten spelen. En als je een Future gebruikt ipv een Task kan je wachten totdat ze klaar zijn. Kijk maar eens in de javadoc van Future.

[Waster]

Bedankt. Ik heb nog nooit van futures gehoord, dus ik moet me even inlezen. Ik ben er echter ook achter gekomen dat dit lijkt te werken:

Java:

for(int i=0; i<100; i++)
    try{threadList[i].join();}catch(Exception e){}

Als dit wordt uitgevoerd na mijn eerste java code wordt eerst gewacht tot al deze threads zijn gestopt. Ik had verwacht dat dan alsnog partij voor partij zou gaan, maar dat is niet zo

[Nick The Heazk]

Waster schreef op zaterdag 22 maart 2008 @ 22:30:
Als dit wordt uitgevoerd na mijn eerste java code wordt eerst gewacht tot al deze threads zijn gestopt. Ik had verwacht dat dan alsnog partij voor partij zou gaan, maar dat is niet zo

Een join is zoiets als: "Ik wacht tot jij, ja jij daar, gedaan hebt". Alle anderen, waar niet naar gewezen wordt, mogen rustig verder werken. Daarom is het dus perfect mogelijk dat de partijen niet in oplopende volgorde voltooid worden.

[Alarmnummer]

Ik zou 2 dingen aanpassen:

1) Ipv zelf met threads te pielen, gebruik een executor. Hiermee verhinder je dat je veel te veel threads loopt te spawnen, maar je kunt ze recyclen, eigenschappen instellen (zoals priority) en tracken (bv interrupten bij bv een shutdown)

2) Voor het 'doorgaan als iedereen klaar is' zou je kunnen kijken naar een CyclicBarrier of een CountdownLatch. Lees de javadoc voor meer informatie.

[edit]
wel ff oppassen met de maxium poolsize van de executor. Stel dat je 5 taken hebt en 4 werkers (dus poolsize = 4) dan zou je wel eens kunnen deadlocken.

[ Voor 16% gewijzigd door Alarmnummer op 25-03-2008 08:03 ]