Vectoren Threads, und Multi Operationen

[Guest]

Hallo Liebe UG , Liebes Forum , Lieber Leser usw...


im Rahmen div. Projekte bin ich auf das Threading gestossen .

Und nun möchte ich eine Reihe von Operationen , die in einem Vector stehen , als Thread starten .Aber der Thread der gestartet wird , muss erst abgewartet werden bis der nächste gestartet wird.

Das sollte in meinem Falle nicht sein , da es sich um sagen wir mal Punkte, handelt, die gleichzeitig in einen Proezss geführt werden müssen.

Also meine Frage nun , wie kann ich meiner Software , ein Professionelles Multithreading Injizieren?

das Quasi alle im Vector bereitgestelleten Prozessnummern , gleichzeitig in einen aktiven Thread uebergehen und dann nach erledigun selbst wieder , diesen Thread verlassen oder ihn auflösen?

 

[Oskar]

Wenn ich das richtig versteht willst du mehrere Threads starten, wobei die Threads zeitgleich gestartet werden sollen? Korrekt?

Wenn dem so ist meine ich dich enttäuschen zu müssen. Zwar gäbe es bestimmt Möglichkeiten die Threads per Timing quasi parallel zu statrten, doch auf Maschinen ebene werden die Aufrufe wieder serialisiert (es sei denn du hast für jeden Thread einen eigenen Prozessor).

Du kannst die Threads am Besten nacheinander starten und dich auf das Scheduling der VM verlassen. Das reicht idR aus um eine ausreichende Paralellität zu erstellen.

Cheers

 

[Guest]

Danke soweit,


also die Tasks sollen Quasi zur selben Zeit starten können , und zu verschiendenen zeiten enden.

Unter Perl z.b geht das .Da wird sogar vom Betriebsystem für jeden Thraed ein neuer prozess erzeugt, und der läuft dann unter Linux mit eigenständiger PID !

Unter Java VM , wird natürlich nur eine JVM für alle Thraeds benutzt richtig?

Wichtig ist eben, man hat eine Liste mit gewissen Aktionen , die erledigt werden müssen.

Das Problem ist nur wenn der eine Task eine Latenz zeit von 1 Minute hat, wird der nächste task erst in einerMinute, also dann wenn Task 1 fertig ist , Ausgeführt.

Das geht aber nicht.

Gibt es keine Signale , die dem nächsten Task Signalisieren :



Ja , Task 1 hat begonnen und benötigt die Info von Task 2 .

Task 2 bitte starten... ?

Bissi pseudo Code...

while(alles ok) {





hole alle anstehenden  prozesse von vector X ;
int F = zähle alle anstehenden prozesse ;
// Quasi für jeden Wert im Vector x , starte jetzt , den prozess/thread y 
for (d = 0; d = f ; d++){
thraed = neuer thread(aktion);
starte den tread d;

randomZeit = generiere zeit in millisekunden;

warte bis die variabele (latenzzeit = randomzeit) ,  vorbei ist ;

kill thread ;



}



}

 

[Beni]

Ich bin mir nicht sicher, auf welcher Ebene du Informationen benötigst... sieht mir aber so aus, als würdest du einfach die Syntax nicht kennen.

In Java werden Threads so gebaut:

public class Task extends Thread{
  // Der Thread lebt solange, wie etwas in dieser Methode geschieht
  public void run(){
    // mach was....
  }
}

Und so wird ein Thread dann gestartet

public void startEinTask(){
  Task task = new Task();
  task.start();

  // hier gehts gleich weiter, während die "run"-Methode von Task ausgeführt wird
}

 

[PyroPi]

Das Problem ist nur wenn der eine Task eine Latenz zeit von 1 Minute hat, wird der nächste task erst in einerMinute, also dann wenn Task 1 fertig ist , Ausgeführt.

Das geht aber nicht.

Gibt es keine Signale , die dem nächsten Task Signalisieren :

Ja , Task 1 hat begonnen und benötigt die Info von Task 2 .

Task 2 bitte starten... ?

Doch, das geht! Du legst Thread I mittels wait (oder war es sleep?) schlafen und weckst ihn wenn Thread II fertig ist über notify/notifyAll. Du mußt vorher natürlich noch irgendwelche Bedingungen festlegen, die einem Thread sagen, ob er schon weitermachen kann. Könnte ja passieren, das der schlafende Thread irgendwann von woanders wach gemacht wird.

 

[Mnemo]

Vielleicht hilft folgendes ja fürs Verständnis:

Task task1 = new Task();
Task task2 = new Task();
Task task3 = new Task();
Task task4 = new Task();

task1.start();
task2.start();
task3.start();
task4.start();


Wenn du obiges in deinem Programm machst. Und z.B. jeder Task die Zahlen 1 - 100 Auf System.out ausgibt.
Könntest du folgende Varianten als Ergebnis bekommen.

Beispiel 1:
1 2 3 4...100 1 2 3...100 etc.

Wahrscheinlicher ist aber folgendes:

Beispiel 2:
1 2 4 5 1...100 etc.

Nachdem du die 4 Threads gestartet hast laufen jene schon 'quasi' parallel ab.

Es bleibt nun dem Scheduler der VM überlassen, der entscheidet, wann welcher Thread auf System.out schreibt und das ist eben unsynchronisiert also zufällig. Für ein Ergebnis wie in Beispiel 1 müßtest du mit synchronized (){} in der run()-Methode arbeiten.

Wen du Mehrere Prozessoren hast könntest du z.B. mit der VM direkt arbeiten z.B. Runtime.getRuntime().availableProcessors() etc.

 

[Guest]

Boah , lieben Dank.



Also @ PyroPi:

Doch, das geht! Du legst Thread I mittels wait (oder war es sleep?) schlafen und weckst ihn wenn Thread II fertig ist über notify/notifyAll. Du mußt vorher natürlich noch irgendwelche Bedingungen festlegen, die einem Thread sagen, ob er schon weitermachen kann. Könnte ja passieren, das der schlafende Thread irgendwann von woanders wach gemacht wird.

Genau das hab ich gemacht und der Thread wartetet bis der 1. Thread Quasi "ausgeschlafen hatte" .

Was aber so nicht sein soll.

Er soll via wait oder sleep in den Schlafmode übergehen , aber nicht , warten bis dieser fertig sondern , nach dem wait oder sleep, den nächsten Thrad starten der dann genau das selbe macht.


Also wie ein Multitasking System , das zwar sequenziell arbeitet , weil die cpu das nur so zulässt , aber trotzdem "gleichzeitig" die tasks abbarbeitet!


( Drucken und , installieren von Software z.B )

Das geht ja hier mit Notify !

aber das mit dem Notify hab ich nich ganz gerafft!

Was bedeutet das , und wie setzt man das ein?


Wenn der Thrad schlafen geht , sendet er ein Notify "wohin", und was geschieht dann genau?

 

[PyroPi]

Also wie ein Multitasking System , das zwar sequenziell arbeitet , weil die cpu das nur so zulässt , aber trotzdem "gleichzeitig" die tasks abbarbeitet!

Na das ist doch genau das Prinzip, nachdem die Threads arbeiten. Du startest alle Threads auf einmal und läßt sie dann quasi parallel ihre Aufgaben abarbeiten.

Genau das hab ich gemacht und der Thread wartetet bis der 1. Thread Quasi "ausgeschlafen hatte" .

Was aber so nicht sein soll.

Er soll via wait oder sleep in den Schlafmode übergehen , aber nicht , warten bis dieser fertig sondern , nach dem wait oder sleep, den nächsten Thrad starten der dann genau das selbe macht.

Das klingt jetzt so, als würdest du wollen, daß sich die Threads der Reihe nach gegenseitig starten. Dann mußt du aber aufpassen: Wenn sich ein Thread schlafen legt und danach erst einen anderen Thread startet, dann passiert das ja nicht, weil sich der Thread gerade schlafen gelegt hat. Vielleicht wird er irgendwann mal wieder geweckt und startet dann erst (als nächste Anweisung) den anderen Thread. Du müßtest also erst den anderen Thread starten und den ersten danach schlafen legen.

Das geht ja hier mit Notify !

aber das mit dem Notify hab ich nich ganz gerafft!

Was bedeutet das , und wie setzt man das ein?

Wenn der Thrad schlafen geht , sendet er ein Notify "wohin", und was geschieht dann genau?

Nein, er sendet nicht notify. Notify rufst du auf dem selben Objekt auf, auf dem du einen Thread schlafen gelegt hast. Dann sucht sich der Scheduler (zufällig) einen Prozess in der Warteschlange, der als nächster an die Reihe kommt. Das entspricht also einem wakeup. NotifyAll weckt einfach alle schlafenden Prozesse in der Warteschlange.

 

[Guest]

Ah , und das meinst du funktioniert das man erst den einen thread schlafen legen sollte wenn der 2 gestartet ist.

Hmm klingt gut , aber ohne es jetzt auszuprobieren, denk ich mir bei meinen vorherigen versuchen eine solche Sache zu Programmieren , schlug es immer fehl das der 1 prozess schlafen ging , und der andere erst dann gestatet wurde , wenn der erste ausgeschlafen hatte (oder wach bzw. finish ist);


nun wuerde das sich ja lediglich um einen thread verschieben, naemlich das beim 2 thread der 3 erst dann ausgefuehrt wird wenn der 2. ferti geschlafen hat...

oder ?

 

[Guest]

OK vielleicht erklär ichs immer zu, Falsch.

public void doit extends Thread {



System.out.println("Thraed gestartet" );

sleep(2000);
System.out.println("Thraed beendet" );

}


Thread task1 = new Thread(doit);
Thread task2 = new Thread(doit);
Thread task3 = new Thread(doit);

task1.start();
task2.start();
task3.start();

}

So auf der Maschien steht jetzt :

Thraed gestartet ... thread beendet Thraed gestartet ... Thread beendet

Ich möchte aber das da steht

Thread gestartet Thread gestartet Thread gestartet .... Thread beendet usw..

Wie genau macht man das?

 

[Beni]

Wenn ich sowas mache:

public class Test implements Runnable{
	public static void main(String[] args) {
		new Thread( new Test() ).start();
		new Thread( new Test() ).start();
		new Thread( new Test() ).start();
		new Thread( new Test() ).start();
	}
	
	public void run() {
		for( int i = 0; i < 100; i++ ){
			System.out.println( i );
			try {
				Thread.sleep( (int)(Math.random() * 1000) );
			} catch (InterruptedException e) {
				return;
			}
		}
	}
}

... kommt als Ausgabe etwas wie

0
0
0
0
1
2
1
3
1
1
4
2
2
2
3
5
4
3
5
3
4
5
6
4
5
6
6
6
7
8
7
7
9
7
8
8
8
10

Und dieses Verhalten willst du? Die asynchronen Effekte tretten nicht immer sofort auf, es benötigt ein bisschen Zeit damit die Threads durcheinander gemischt werden.

 

[Illuvatar]

Oder um mal genau dein Beispiel aufzugreifen:

public class ThreadTest
{
  public static void main(String[] args)
  {
    Thread t1 = new Doit();
    Thread t2 = new Doit();
    Thread t3 = new Doit();
    
    t1.start();
    t2.start();
    t3.start();
  }
}
class Doit extends Thread
{
  public void run()
  {
    System.out.println("Gestartet");
    try{
      Thread.sleep(2000);
    }catch (Exception e){
      //Should never happen
      e.printStackTrace();
    }
    System.out.println("Beendet");
  }
}

gibt bei mir aus:

Gestartet
Gestartet
Gestartet
Beendet
Beendet
Beendet

 

[Guest]

Wie wäre es mit yield()?

public class Test implements Runnable{
   public static void main(String[] args) {
      new Thread( new Test() ).start();
      new Thread( new Test() ).start();
      new Thread( new Test() ).start();
      new Thread( new Test() ).start();
   }

   public void run() {
      for( int i = 0; i < 100; i++ ){
         System.out.println( i );
         Thread.currentThread().yield(); // Kontrolle an den nächsten Thread übergeben
      }
   } 
}

Die einzelnen Threads laufen dann quasi parallel.

 

[Dominicana]

Gibt es die Möglichkeit , das ganze auch in einem Applet zu realisieren???

Beispielsweise einen Musiktitel abspielen und die dazugehörenden Infos mittels drawString("xyz", x , y) im Applet scrollen lassen.

Dom.

 

[byte]

public void doit extends Thread {



System.out.println("Thraed gestartet" );

sleep(2000);
System.out.println("Thraed beendet" );

}


Thread task1 = new Thread(doit);
Thread task2 = new Thread(doit);
Thread task3 = new Thread(doit);

task1.start();
task2.start();
task3.start();

}

So auf der Maschien steht jetzt :

Thraed gestartet ... thread beendet Thraed gestartet ... Thread beendet

Ich möchte aber das da steht

Thread gestartet Thread gestartet Thread gestartet .... Thread beendet usw..

Wie genau macht man das?

Poste doch mal den genauen Code. Der oben kann ja so nicht richtig sein.

Irgendwie vermute ich, dass Du den Unterschied zwischen Thread und Task (Runnable) nicht kennst. Denn die Ausgabe lässt eher vermuten, dass Du die Tasks im selben Thread aufrufst.

 

[Leroy42]

Gibt es die Möglichkeit , das ganze auch in einem Applet zu realisieren???

Sicher!

Poste doch mal den genauen Code. Der oben kann ja so nicht richtig sein.

Irgendwie vermute ich, dass Du den Unterschied zwischen Thread und Task (Runnable) nicht kennst. Denn die Ausgabe lässt eher vermuten, dass Du die Tasks im selben Thread aufrufst.

Der Code der gepostet wurde, war doch sowieso nur Pseudocode.

Es wäre hilfreich wenn OP genauer beschreiben würde wann seine Threads
parallel ablaufen dürfen/sollen und wann sie aufeinander warten müssen.

Ich denke schon daß es hinzubekommen ist; die Frage ist nur, was es eigentlich ist.