# Threads Rückgabewert



## cleanAir (23. Juni 2010)

Guten Abend
Rechfertigung: Boardsuche und Google benutzt, keine passende Lösung gefunden.

Zum Thema:
Ich habe eine normale Main Klasse die mittels for Schleife "n" Threads erstellt
Hier ein Beispiel;


```
fibThread f = null;
        for (int i = 0; i < numberArray.length; i++) {
            try {
                f = new fibThread(numberArray[i], i, size, startTime);
                f.start();
                
            } catch (Exception e) {
                newray[i] = -1;
            }

        }
```
Jeder Thread hat eine unterschiedliche Laufzeit und soll ein Ergebnis zurückgeben.
Die run() Methode sieht aber keinen Rückgabewert vor. Somit habe ich es mittels eines Getters versucht auf die jeweiligen Ergebnisse zuzugreifen (von der Main aus).

Leider ohne Erfolg (es kommt immer 0 raus (aufgrund der 0 die ich keim initialisieren festlege).
Ich habe daraufhin den Start der Thrads in ein "synchronized" block gepackt sowie auch den "Getter" in der Thrad Methode um die überspeicherung zu verhindern. Leider ebenfalls ohne Erfolg )es kommt immernoch der wert 0 raus.

Wir nochmal der Inhalt der Thread Klasse

```
public class fibThread extends Thread {

    int input;
    int result;

    fibThread(int input) {
        this.input = input;
    }

    fibThread() {
    }
    
    @Override
    public void run() {
        try {
            
            result = FibCalc.fib(input);
            
            //synchronized (this) { //Die Ausgabe ist Synchronisiert
                //result = FibCalc.fib(input);
            //}
        } catch (FibException e) {
            e.printStackTrace();
        }
    }
    
    public int getResult()
    {
        return result;
    }
}
```


----------



## zerix (23. Juni 2010)

Hallo,

schau dir mal den ExecutorService und Callable an.
http://blogs.sun.com/CoreJavaTechTips/entry/get_netbeans_6

Gruß

Sascha


----------



## cleanAir (30. Juni 2010)

Hallo,
danke aber wegen der Concurrent Klasse ist das verwenden nicht erlaubt.

Ich habe das Problem ganz einfach mit einem Array von dem Typ Thread gelöst. 
Jeder Thread wird durch eine For-schleife gestaretet und schreibt sein Ergebnis, so wie er fertig geworden ist in das Array an den jeweiligen Index.

Auf dieser weise wird kein synchronized benötigt.

Der letzte Thread des Arrays wird noch mittels join mit dem Main Thread verbunden und das fertige Array aus der Methode zurückgegeben.


----------



## gorefest (30. Juni 2010)

Btw, Du baust da einen "Metathreadpool" nach.

Java verfügt über adäquate Möglichkeiten, eine Aufgabe auf mehrere Threads zu verteilen und threadsicher die Ergebnisse einzufangen.

Ich schließe mich der Empfehlung an, einen Executorservice zu nehmen, da selbiger auch Threadabbrüche und einen endlichen Zeitpunkt für das Verarbeitungsende vorsieht. Wenn Du mit Deiner Schleife zu viele Threads aufmachst, flutest Du Deinen Rechner.

Es gibt unterschiedliche Typen von Executorservices. Hier ein Beispiel (Freestyle):


```
ExecutorService exe = Executors.newFixedThreadPool(threadPoolSize);
		ArrayList<Future<Integer>> results = new ArrayList<Future<Integer>>();
		for (int i = 0; i < maxthreads; ++i) {
			DeineSwarmklasse wrap = new DeineSwarmklasse ();	
			Future<Integer> r = exe.submit(wrap);
			results.add(r);
		}

		Thread.sleep(250);
		Thread.yield();
		exe.shutdown();
		exe.awaitTermination(1000, TimeUnit.MILLISECONDS);
		
		List<Runnable> neverActivateds = exe.shutdownNow();
		for (Runnable runnable : neverActivateds) {
			DeineSwarmklasse el = (DeineSwarmklasse ) runnable;
                       ... Fehlerbearbeitung für die niemals gelaufenen ...
		}
		for (Iterator<Future<Integer>> iter = results.iterator(); iter.hasNext();) {
			Future<Integer> fut = iter.next();
			try {
                               fut.get(250, TimeUnit.MILLISECONDS);	

			} catch (Exception ex) {
				... Fehlerhandling ...
			} 
		}	
		if (failedlogFilePaths.size()>0) { returnCode = ReturnCode.PART;}
```

Deine Swarmklasse muss nur noch Runnable implementieren und fertig ist das Threading


----------

