Hallo allerseits,
bin neu hier im Forum. Hab schon einige Erfahrungen mit Java gemacht, beiße mir aber am Thema Threads die Zähne aus. Während ich mich u.a. durch die Java-Insel und einige Tutorials gequält habe, sind schon etliche Programmierversuche ins Land gegangen. Meine Versuche mit synchronized, volatile, wait, notify und Co. haben bei mir nur dazu geführt, das mehrere Threads nacheinander und nicht parallel von einem Hauptthread bedient wurden. Da habe ich wohl was nicht richtig verstanden.
In dem folgenden Programm habe ich einfach mal drauf losgelegt und das Ergebnis scheint so zu funktionieren, wie ich's mir vorstelle: parallel und - ich hoffe - fehlerfrei.
Im s.g. Hauptthread (Ht) werden zwei Threads (Consumer) erzeugt und mit Aufgaben (Zahlen) gefüttert. Hat ein Thread eine Aufgabe erledigt, durchläuft er ständig eine Schleife, um zu prüfen, ob der Ht eine weitere Aufgabe für ihn hat. Nach erfolgreicher Bearbeitung wird, als Signal erneuter Aufnahmebereitschaft an den Ht, ein Trigger auf false gesetzt. Dieser wird zyklisch vom Ht abgefragt. Erkennt dieser den Trigger als false, schickt er erneut eine Aufgabe an den jeweiligen Thread und setzt dessen Trigger auf true, was für den Consumer wiederum das Signal zum erneuten run-Durchlauf ist.
Wenn alle Aufgaben erledigt sind, erhält jeder Consumer-Thread ein Abbruchsignal (-1 als Aufgabe), um sich selber zu beenden.
Meine eigentliche Frage bzw. Bitte lautet nun, mir die richtige Richtung zu weisen. Sprich: Hat jemand einen besseren Lösungsvorschlag, um mehrere Threads bestimmte Aufgaben parallel abarbeiten zu lassen. Ich bitte Euch um aktive Meinungsäußerung.
Und noch etwas. Wie ich bereits erwähnte, bin ich neu hier in diesem Forum. Das soll heißen, dass man mir, falls dieses Threads-füttern-Thema hier bereits zur Genüge gefragt, diskutiert und behandelt wurde, vergeben möge. Gleiches gilt für den Fall, dass ich zu :autsch: sein sollte, nach dem richtigen Foreneintrag zu suchen.
Ich bin für jede Hilfe und jeden Hinweis dankbar.
MfG Patrick
bin neu hier im Forum. Hab schon einige Erfahrungen mit Java gemacht, beiße mir aber am Thema Threads die Zähne aus. Während ich mich u.a. durch die Java-Insel und einige Tutorials gequält habe, sind schon etliche Programmierversuche ins Land gegangen. Meine Versuche mit synchronized, volatile, wait, notify und Co. haben bei mir nur dazu geführt, das mehrere Threads nacheinander und nicht parallel von einem Hauptthread bedient wurden. Da habe ich wohl was nicht richtig verstanden.
In dem folgenden Programm habe ich einfach mal drauf losgelegt und das Ergebnis scheint so zu funktionieren, wie ich's mir vorstelle: parallel und - ich hoffe - fehlerfrei.
Im s.g. Hauptthread (Ht) werden zwei Threads (Consumer) erzeugt und mit Aufgaben (Zahlen) gefüttert. Hat ein Thread eine Aufgabe erledigt, durchläuft er ständig eine Schleife, um zu prüfen, ob der Ht eine weitere Aufgabe für ihn hat. Nach erfolgreicher Bearbeitung wird, als Signal erneuter Aufnahmebereitschaft an den Ht, ein Trigger auf false gesetzt. Dieser wird zyklisch vom Ht abgefragt. Erkennt dieser den Trigger als false, schickt er erneut eine Aufgabe an den jeweiligen Thread und setzt dessen Trigger auf true, was für den Consumer wiederum das Signal zum erneuten run-Durchlauf ist.
Wenn alle Aufgaben erledigt sind, erhält jeder Consumer-Thread ein Abbruchsignal (-1 als Aufgabe), um sich selber zu beenden.
Java:
public class Consumer extends Thread{
private String name;
private boolean trigger;
private int aufgabe; //Was der Thread machen soll
public Consumer( String n ){
this.name= n;
this.trigger= false;
this.aufgabe= 0;
}
public void setAufgabe( int a ){
this.aufgabe= a;
}
public boolean getTrigger(){
return this.trigger;
}
public void setTrigger(){
this.trigger= true;
}
public void run(){
while( true ){
while( !trigger ){
try { sleep( 1 ); } catch ( InterruptedException e ){ e.printStackTrace(); }
}
/********** Aufgabenbereich *****************************************************/
if( aufgabe== -1 ){ // -1 als Abbruchsignal, Thread beenden
System.out.println("\n" + name + " beendet" );
break;
}
System.out.println( name + " " + aufgabe );
try { sleep( aufgabe ); } catch ( InterruptedException e ){ e.printStackTrace(); }
/********************************************************************************/
trigger= false;
}
}
public static void main(String[] args) {
int[] aufgaben= { 10, 20, 30, 40, 500, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200 };
int threadanz= 2;
/***** erzeugen und starten von 2 (threadanz) Consumer-Threads *************/
Consumer []c= new Consumer[threadanz];
for( int i= 0; i< threadanz; i++ ){
c[i]= new Consumer("c" + i);
c[i].start();
}
/***** abarbeiten des aufgaben-Arrays ***************/
int i= 0;
int j= 0;
while( i< aufgaben.length ){
if( j>= threadanz ) j= 0;
if( !c[j].getTrigger() ){
c[j].setAufgabe(aufgaben[i]);
c[j].setTrigger();
i++;
}
j++;
}
/***** alle Consumer-Threads erhalten das Signal zum Beenden (-1) ****/
i= 0;
while( i< c.length ){
if( i>= c.length ) i= 0;
if( !c[i].getTrigger() ){
c[i].setAufgabe(-1);
//c[i].interrupt();
c[i].setTrigger();
i++;
}
}
}
}Meine eigentliche Frage bzw. Bitte lautet nun, mir die richtige Richtung zu weisen. Sprich: Hat jemand einen besseren Lösungsvorschlag, um mehrere Threads bestimmte Aufgaben parallel abarbeiten zu lassen. Ich bitte Euch um aktive Meinungsäußerung.
Und noch etwas. Wie ich bereits erwähnte, bin ich neu hier in diesem Forum. Das soll heißen, dass man mir, falls dieses Threads-füttern-Thema hier bereits zur Genüge gefragt, diskutiert und behandelt wurde, vergeben möge. Gleiches gilt für den Fall, dass ich zu :autsch: sein sollte, nach dem richtigen Foreneintrag zu suchen.
Ich bin für jede Hilfe und jeden Hinweis dankbar.
MfG Patrick
Zuletzt bearbeitet:
