anstatt thread.join() einfach while schleife?

[vimar]

habe 4 threads, anstatt thread1.join(), thread2.join() usw kann ich auch einfahc schreiben:

while(thread1.isAlive() | thread2.isAlive() | 
                    thread3.isAlive() | thread4.isAlive()){
                    
                // NIXXX
            }

? hat den selben effekt oder?

 

[Fab1]

du weißt, dass du hier ein bitweises Oder benützt?

Ein normales Oder ist:

||

 

[JCODA]

du weißt, dass du hier ein bitweises Oder benützt?

Ein normales Oder ist:

||

Naja, ||-Oder vergleicht das 2. Argument nichtmehr wenn das 1. true ist, | würde alle auswerten (und ist damit nicht nur das bit-oder)


@ TO:

eher schlechte Lösung, da der Thread der die Schleife ausführt zuviel Prozessorleistung zieht.

 

[njans]

Das nennt sich aktives warten

Ich meine Marco13 hat das mal so schön ausgedrückt (bitte korrigieren, wenn Quelle falsch): Das macht man nur, wenn es kalt ist und man den Raum unbedingt mit der CPU aufheizen will.

Der Sinn von join ist ja, dass du eben nicht die CPU ins leere laufen lässt, sondern diese sich meldet, wenn sie fertig ist

 

[AlexSpritze]

Ich zitiere mal Marco13 aus einem anderen Thread:

ahrg... So ein while (irgendwas) /* do nothing*/; nennt sich "busy waiting", das macht man nur wenn's kalt ist, und man versucht durch eine sinnlos vor sich hin arbeitende CPU die Zimmertemperatur zu erhöhen.

[EDIT]Hab ich tatsächlich fünf Minuten mit dem Suchen des Zitats vergeudet [/EDIT]

 

[vimar]

danke habs auf || geändert..


ich meine es kann doch net so schwer sein mein problem...

hab ne arrayliste die ich mit 4 threads durchlaufe, weil ich alle kerne der cpu nutzen will.

pseudocode

while(nochNichtAmEndeDerArrayList.size()){

if (!(thead1.isAlive))
{
new thead1(arraylistIndex)
arraylistIndex+1;
}


if (!(thead2.isAlive))
{
new thead2(arraylistIndex)
arraylistIndex+1;
}

USW bis thread4.


wenn die while schleife vorbei ist will ich nen boolean wert in nem objekt vergleichen auf den alle threads zugreifen. hab dieses arraylistIndex+1 auch syncronized..

jedenfalls will ich immer cpu auslastung 100% auf allen 4 kernen. das klappt auch irgendwie soweit. will aber joins() verhindern. brauche aber vllt joins() weil wenn die while schleife verlassen wird kann es ja anoch sein dass ein thread läuft während der boolean schon geprüft wird. daher wollte ich einfach anstatt join() ne whileschleife die einfach so lange läuft bis alle threads.isAlive() = false.

macht das sinn? irgendwie blockt das alles

 

[vimar]

ich habe nebenbei auch shcon überlegt,

t1 kriegt arraylist[0], t2 arraylist[1], t3 arraylist[2], t4 arraylist[3].

der der nun am schnellsten is kriegt arraylist[4], der nächste arraylist[5] (bzw der der nicht alive ist wird neu erstellt).


ist es vllt nicht auch sinnvoll anstatt new thread einfach 4 deamons zu machen (habe keine wirkliche erfahrung damit, nur "insel" gelesen) und den deamons dann einfach nen neues objekt der arraylist übergeben? so hätte ich nicht ständig diese neuen threads die erstellt werden müssten?

 

[njans]

Du könntest auch eine Thread barrier nehmen

Nebenbei: Zwang der Kerne auf 100% zu laufen ist ziemlich komisch. Joins sind da deutlich Sinnvoller als aktives warten.
Entweder müssen alle Threads fertig sein, damit es weiter geht, oder nicht. Je nachdem musst du entscheiden, was du machen willst.

 

[vimar]

also besser zeile 120-124 als zeile 133-137?

erst die letzten 4 objekte der arraylist sollen ins join(), vorher können die ja nach belieben werkeln wie sie wollen dachte ich mir?

import java.util.ArrayList;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */


/**
 *
 * @author vimar
 */

public class Baustelle {
            
            
            int aktuellerZiegelStein = 0; // startarray[0]
            ArrayList <cluster> ZiegelsteinHaufen; // arraymit 1000 objekten
            
            // chef + arbeiter;
            chef cheffe;
           bauarbeiter b1,b2,b3,b4;
            // zuweisung

           
            
    
            public Baustelle(ArrayList <cluster> ZiegelsteinHaufen){
                this.ZiegelsteinHaufen = ZiegelsteinHaufen;
      
                
            cheffe = new chef();
             b1 = new bauarbeiter(ZiegelsteinHaufen,"b1",cheffe); //thread1
            b2 = new bauarbeiter(ZiegelsteinHaufen,"b2",cheffe); //thread2
            b3 = new bauarbeiter(ZiegelsteinHaufen,"b3",cheffe); //thread3
            b4 = new bauarbeiter(ZiegelsteinHaufen,"lahmesPferd",cheffe); //thread4   
                
                
             cheffe.setMaxZiegel(ZiegelsteinHaufen.size()); // -1?   
             cheffe.setB1(b1);
             cheffe.setB2(b2);
             cheffe.setB3(b3);
             cheffe.setB4(b4);
             
                
                
                
            }

            public boolean starteArbeit() throws InterruptedException{
              
              //reset
                cheffe.isChanged = false;
                cheffe.setAktZiegel(0);
             // reset ende  
                
                // cheffe.getB1().stop();
               // cheffe.getB2().stop();
               // cheffe.getB3().stop();
                //cheffe.getB4().stop();
                
                 System.out.println("Nicht alle Centroiden richtig, nochmal alles!");
          while(cheffe.getAktZiegel() < cheffe.getMaxZiegel()){ // && das nochmal in if2,if3,if4
                    
                    
                    
                if (cheffe.getAktZiegel() < cheffe.getMaxZiegel() -4){    
                    if(!(cheffe.getB1().isAlive())){ // wenn der pennt!
                        cheffe.setB1(new bauarbeiter(ZiegelsteinHaufen,"Hugo",cheffe));
                        cheffe.getB1().aktZiegel = cheffe.getAktZiegel();
                        updateAktZiegel();
                        cheffe.getB1().start();
                    }
                    if(!(cheffe.getB2().isAlive())){
                        cheffe.setB2(new bauarbeiter(ZiegelsteinHaufen,"Stefan",cheffe));
                        cheffe.getB2().aktZiegel = cheffe.getAktZiegel();
                        updateAktZiegel();
                        cheffe.getB2().start();
                    }
                    if(!(cheffe.getB3().isAlive())){
                        cheffe.setB3(new bauarbeiter(ZiegelsteinHaufen,"Alex",cheffe));
                        cheffe.getB3().aktZiegel = cheffe.getAktZiegel();
                        updateAktZiegel();
                        cheffe.getB3().start();
                    }
                    if(!(cheffe.getB4().isAlive())){
                        cheffe.setB4(new bauarbeiter(ZiegelsteinHaufen,"Johannes",cheffe));
                        cheffe.getB4().aktZiegel = cheffe.getAktZiegel();
                        updateAktZiegel();
                        cheffe.getB4().start();
                    }
                }
                else
                {
                    if((!(cheffe.getB1().isAlive())) && (cheffe.getAktZiegel() < cheffe.getMaxZiegel())){ // wenn der pennt!
                        cheffe.setB1(new bauarbeiter(ZiegelsteinHaufen,"Hugo",cheffe));
                        cheffe.getB1().aktZiegel = cheffe.getAktZiegel();
                        updateAktZiegel();
                        cheffe.getB1().start();
                    }
                    if((!(cheffe.getB2().isAlive())) && (cheffe.getAktZiegel() < cheffe.getMaxZiegel())){
                        cheffe.setB2(new bauarbeiter(ZiegelsteinHaufen,"Stefan",cheffe));
                        cheffe.getB2().aktZiegel = cheffe.getAktZiegel();
                       updateAktZiegel();
                        cheffe.getB2().start();
                    }
                    if((!(cheffe.getB3().isAlive()))&& (cheffe.getAktZiegel() < cheffe.getMaxZiegel())){
                        cheffe.setB3(new bauarbeiter(ZiegelsteinHaufen,"Alex",cheffe));
                        cheffe.getB3().aktZiegel = cheffe.getAktZiegel();
                        updateAktZiegel();
                        cheffe.getB3().start();
                    }
                    if((!(cheffe.getB4().isAlive()))&& (cheffe.getAktZiegel() < cheffe.getMaxZiegel())){
                        cheffe.setB4(new bauarbeiter(ZiegelsteinHaufen,"Johannes",cheffe));
                        cheffe.getB4().aktZiegel = cheffe.getAktZiegel();
                        updateAktZiegel();
                        cheffe.getB4().start();
                    }
                    
                  //  if (cheffe.getB1().isAlive()) cheffe.getB1().join();
                  //  if (cheffe.getB2().isAlive()) cheffe.getB2().join();
                   // if (cheffe.getB3().isAlive()) cheffe.getB3().join();
                   // if (cheffe.getB4().isAlive()) cheffe.getB4().join();
                   
                }
                    
                    
                    
                }

       //    Thread.sleep(100);

            while(cheffe.getB1().isAlive() || cheffe.getB2().isAlive() || 
                    cheffe.getB3().isAlive() || cheffe.getB4().isAlive()){
                    
                // NIXXX
            } 
          
            if (!(cheffe.isChanged)){
                
                System.out.println("sind wohl fertig -.-");
                return false; // legendärer punkt wenn mal alles fertig is -.-
               
                
            }
            
            return true; // returned true und geht somit wieder in diese fkt.
                        // könnte auch "return startearbeit();" schreiben.
            
            }
            
            
      public synchronized void updateAktZiegel(){
          
          
          cheffe.setAktZiegel(cheffe.getAktZiegel()+1);
          
          
      }
    
}