Threads Java Thread kommunizieren

[ben89]

hallo an alle

ich habe ein problem bei meinem programm, das ich parallelisieren möchte:

ich habe ein array, indem werte stehen. das array steht für eine art zellularen automaten, d.h., die werte die im array sind werden durch einen algorithmus verändert. jede änderung ist mit einem zeitschritt gleichzusetzen.

das array teile ich in teilarrays auf und übergebe jedem thread ein teilarray zum berechnen.
zum berechnen muss der thread aber werte kennen, die im teilarray eines anderen thread sind.
da die berechnung wiederholt durchgeführt werden muss (weil mehrere zeitschritte simuliert werden sollen), was in der run erfolgt, reicht es nicht aus die werte beim start mit zu übergeben.
wie kann ich nun von einem thread auf das teilarray eines anderen thread zugreifen?

über jede hilfe bin ich dankbar

 

[Gucky]

Möglich wäre es das Teilarray als Klassenvariable in den Threads zu deklarieren und dann den beiden Threads je eine Instanz des Anderen zu geben.

 

[ben89]

danke für die antwort.
ich möchte aber von einem thread auf einen anderen zugreifen. geht das nicht?

 

[turtle]

Klar geht das...

Ist aber aufwändig zu synchronisieren, da ja jeder der Threads ein Teilarray ändern könnte.

 

[Gucky]

Doch. Der Thread ist nichts anderes, als eine Klasse, mit einer Methode, die Zyklisch aufgerufen wird. Dann kannst du Methoden in den Threads haben, auf die der andere zugreifen kann.

Ich verstehe grade deine Frage nicht richtig. Das war es doch, was ich geschrieben habe.

 

[ben89]

Klar geht das...

Ist aber aufwändig zu synchronisieren, da ja jeder der Threads ein Teilarray ändern könnte.

Ja das efolgt auch später. Das Prinzip der Synchronisation (wann wer auf wen warten muss) ist auch fertig (im Kopf).
Bloß wie greife ich auf einen anderen Thread zu? Mal Pseudocode-mäßig:

public run(){
 int [] arrayVomAnderenThread= ts.id.teilarray;  //Hier weiss ich nicht, wie es geht :(
}

public main(){
 thread ts = new thread( teilarray );
 ts.start();
}

 

[Gucky]

Möglich wäre es auch noch das Array extern zu haben und beide Threads darauf zugreifen zu lassen.

 

[ben89]

ja genau das versuche ich gerade. wenn es geklappt hat, melde ich mich nochmal.

danke für die hilfe bisher :applaus:

 

[turtle]

public class X {
	public static void main(String[] args) {
		int[] teilarray1 = new int[] { 1, 2, 3 };
		int[] teilarray2 = new int[] { 4, 5, 6 };
		TeilArrayThread ts1 = new TeilArrayThread(1, null, teilarray1);
		TeilArrayThread ts2 = new TeilArrayThread(2, null, teilarray2);
		ts1.setTeilThread(ts2);
		ts2.setTeilThread(ts1);
		ts1.start();
		ts2.start();
		// 1: { 1, 2, 3}
		// 1: { 4, 5, 6}
		// 2: { 4, 5, 6}
		// 2: { 1, 2, 3}

	}
}

class TeilArrayThread extends Thread {
	private int[] dasTeilArray;
	private TeilArrayThread ts1;
	private int threadNr;

	TeilArrayThread(int threadNr, TeilArrayThread ts1, int[] teilArray) {
		this.threadNr = threadNr;
		this.dasTeilArray = teilArray;
		this.ts1 = ts1;
	}

	public void setTeilThread(TeilArrayThread ts2) {
		this.ts1 = ts2;
	}

	public int[] getDasTeilArray() {
		return dasTeilArray;
	}

	@Override
	public void run() {
		int[] dasTeilArray2 = getDasTeilArray();
		output(threadNr, dasTeilArray2);
		int[] dasTeilArray3 = ts1.getDasTeilArray();
		output(threadNr, dasTeilArray3);
	}

	private void output(int threadNr, int[] dasTeilArray) {
		StringBuilder sb = new StringBuilder();
		sb.append("" + threadNr + ": ");
		sb.append("{ ");
		int n = 0;
		for (int i : dasTeilArray) {
			if (n > 0) {
				sb.append(", ");
			}
			sb.append(i);
			n = 1;
		}
		sb.append("}");
		System.out.println(sb.toString());
	}
}

 

[slothsoft]

Vielleicht sei die Frage gestattet, warum du überhaupt Threads dafür benutzen willst. Üblicherweise sollten nur Aufgaben parallelisiert werden, die in unabhängige Teilaufgaben zerlegt werde können und wo die Reihenfolge der Teilaufgabe keine Rolle spielt. Falls es um Geschwindigkeit geht: Durch die Synchronisierung der Threads und eventuelle Deadlocks verbrät man unter Umständen mehr Zeit als durch eine serielle Abarbeitung.

 

[ben89]

die Frage ist berechtigt: ich habe das als Aufgabe bekommen

 

[nvidia]

Vielleicht sei die Frage gestattet, warum du überhaupt Threads dafür benutzen willst. Üblicherweise sollten nur Aufgaben parallelisiert werden, die in unabhängige Teilaufgaben zerlegt werde können und wo die Reihenfolge der Teilaufgabe keine Rolle spielt. Falls es um Geschwindigkeit geht: Durch die Synchronisierung der Threads und eventuelle Deadlocks verbrät man unter Umständen mehr Zeit als durch eine serielle Abarbeitung.

Die Implementierung von solchen zellulären Automaten wie z.B. dem Game of Life bestehen meist aus 2 Datenobjekten. Würde man nur auf einem Feld arbeiten würde man sich Werte überschreiben während die Epoche noch läuft. Der Zeitverlauf ist also nicht parallelisierbar. Bevor man vom Zeitpunkt t nach t+1 übergeht muss man der Zustand fertig sein.

Aber der Aufbau des Zustands ist parallelisierbar. Es gibt dann ein Feld das den aktuellen Zustand symbolisiert. Aus diesem Feld wird nur gelesen, das ist für eine Parallelisierung unkritisch. Des Weiteren gibt es das Feld für den nächsten Zustand, in das geschrieben wird und zwar auf Basis der Regelanwendungen vom ersten Feld. Das Schreiben ist genauso unkritisch da man den verschiedenen Threads vorher sagen kann, welchen Bereich sie beschreiben dürfen in dem man den Wertebereich aufteilt. Beispielsweise werden Thread A die Zeilen 0..m, und anderen Thread B die Zeilen m+1..n-1 zur Verarbeitung zugewiesen.

Es ist also bei dieser Art der Verarbeitung überhaupt keine Synchronisierung auf die Daten selbst notwendig. Synchronisiert werden müssen nur die Threads auf den Zeitpunkt des nächsten Übergangs, da diese ja unterschiedlich schnell fertig sein können. Java bietet dazu Verschiedenes im Concurrent Package, für diesen Typ Arbeit im Speziellen wäre wohl Fork/Join angebracht.

 

[Ruzmanz]

Wollt auch grade schreiben, dass diese Aufgabe nach Fork/Join klingt. Sofern du die Klasse Thread nimmst, würde ich einfach noch den Zustand in einer zusätzlichen Klasse speichern, deren Referenz jeder Thread kennt. Ganz grob:

public class Zustand {
  int[] array;
  int[] oldArray;
  int zustand t1 = 0;
  int zustand t2 = 0;
}

public class Berechnung extends Thread {
  private Zustand  zustand;

  public void run() {
    while(aufgabeNichtErledigt) {
      if(zustand.t1 == zustand.t2) {
        // Aufgabe bearbeiten
        // zustand.t1++ bzw. zustand.t2++
      } else {
        // Thread.sleep() ...
      }
    }
  }
}

PS: Evtl. sollte der letzte Thread auch noch eine Kopie im oldArray ablegen. Damit alle Threads die Werte vom Zustandsanfang kennen. Zum Beispiel wird t1 als letztes fertig und startet gleich die nächste Berechnung. Bis t2 merkt, dass ein neuer Zustand begonnen hat, hat t1 aber schon den neuen Wert ins array abgelegt und somit würde t2 auf die falschen Daten zugreifen.