String an Future übergeben?

[öhm]

hi ich hab mir ein mehr oder minder verschachteltes gerüst aus threads zusammengebastelt mit executorService und Fututre.

manche haben feste aufgaben andere sollen funktionen evaluieren und anhand eines string , sozusagen eines komandos diese ausführen, ich hab mir jetzt future in verschiedensten ausführungen angeschaut und durchgepsielt aber wie kann ich einen String übergeben?

oder geht das nur indem ich den spass in eine art Stack array schreibe und den arrayfeldern dann die namen der threads gebe um dem entsprechenden thread über diesen Umweg die norwendigen informationen zukommen zu lassen?

 

[Thomas Darimont]

Hallo!

Ein Future ist nur eine Art "Handle" auf das Ergebnis eines Callable Tasks. Du müsstest den zu Evaluierenden String an den Callable Übergeben...

/**
 * 
 */
package de.tutorials;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @author Tom
 *
 */
public class FormulaEvaluationExample {

	/**
	 * @author Tom
	 *
	 */
	static class FormulaEvaluator {
		public static String evaluate(String formula) {
			return "3"; //dummy... ;-)
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		ExecutorService executorService = Executors.newCachedThreadPool();
		final String formula = "1+2";
		Future<String> future = executorService.submit(new Callable<String>(){
			public String call() throws Exception {
				return FormulaEvaluator.evaluate(formula);
			}
		});
		
		try {
			String value = future.get();
			System.out.println(value);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		executorService.shutdown();
	}

}

Gruß Tom

 

[öhm]

hmm und das soll bei einer asynchronen programmierung bei der mehrere threads nahezu gleichzeitig gestaretet werden und unterschiedliche operationen ausführen sollen, immer so klappen das der entsprechende string auch im richtigen thread ankommt?

die müssten dann ja alle dann darauf zugreifen, was wenn ein thread mal etwas hängt oder eine längere laufzeit hat?

entschuldige wenn ich etwas skeptisch in ,rein theoretisch wäre es egal welcher thread was abarbeitet, nur müsste ich in der evaluate funktion dann auch einen stack einbauen um überschreibungen zu vermeiden oder?


Gruss Sascha

 

[Thomas Darimont]

Hallo!

Das war ja auch nur ein einfaches Beispiel um die Bedeutung von Futures klar zu machen...

/**
 * 
 */
package de.tutorials;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

/**
 * @author Thomas.Darimont
 * 
 */
public class FutureTaskExample {

    /**
     * @param args
     */
    public static void main(String[] args) {
        ExecutorService executorService = Executors
                .newCachedThreadPool();

        Future<String> future = executorService
                .submit(new FunctionEvaluator("1+2"));
        try {
            String result = future
                    .get();
            System.out
                    .println(result);
        } catch (Exception e) {
            e
                    .printStackTrace();
        }

        executorService
                .shutdown();

    }

    static class FunctionEvaluator implements Callable<String> {

        String function;

        public FunctionEvaluator(String function) {
            this.function = function;
        }

        public String call() throws Exception {
            TimeUnit.SECONDS
                    .sleep(3);
            return evaluate();
        }

        private String evaluate() {
            return "3";
        }
    }

}

Gruß Tom

 

[öhm]

Hallo!

Das war ja auch nur ein einfaches Beispiel um die Bedeutung von Futures klar zu machen...

hm ja schön die ganzen beispiele wo nichts übergeben wird kenne ich schon. ich mein ... wo hast du jetzt da irgendwo irgendwelche werte übergeben die du irgendwie irgendwo weiter verwendest und die NICHT schon vorher da STATISCH drin stehen sondern die zur laufzeit anliegen?

/**
 * 
 */
//package de.tutorials;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.*;

/**
 * @author Thomas.Darimont
 * 
 */
public class FutureTaskExample {
	String hallo = "Hallo";
    /**
     * @param args
     */
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
 Future<String> future = executorService.submit(new FunctionEvaluator(hallo));
        try {
            String result = future.get();
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }

        executorService.shutdown();

    }

    static class FunctionEvaluator implements Callable<String> {
        String function;
        public FunctionEvaluator(String function) {
            this.function = function;
        }

        public String call() throws Exception {
            TimeUnit.SECONDS.sleep(3);
            return evaluate();
        }

        private String evaluate() {
            return this.function;
        }
    }

}

^^ ums an deinem beispiel zu erklären!

Cannot make a static reference to the non-static field hallo

ich lese zur information daten (aus einem stream) ein während das programm schon fertig compiliert ist und läuft nun wäre es schön wenn ich auch diese nutzen könnte denn ich bin zwar gut aber ich weiss noch nicht welche daten das sein werden daher kann ich die jetzt so einfach statich in den quelltext schreiben wie du

entschuldige den zynismuss vielleicht bin ich auch einfach nur zu blöd dafür.


Gruss Sascha

 

[Thomas Darimont]

Hallo!

Wenn du ein Attribut innerhalb eines statischen Kontextes verfügbar machen willst, musst du es natürlich auch als static deklarieren ;-)

Na ja, was willst du eigentlich genau tun?
Du hast ein Konstrukt (den Stream) der dir ständig neue Funktionen generiert (Generator/Producer). Dann hast du ein weiteres Konstrukt welche die generierten Funktionen aufsammelt (eine Queue). Diese wird von einem FunctionEvaluator (Consumer) ausgelesen welcher dann die darin gefundenden Funktionen evaluiert. Da die Evaluierung je nach Funktion etwas länger dauern kann möchtest du diesen Prozess parallelisieren. Hierzu möchtest du gerne Futures verwenden die als Ergebnis das Resultat der Evaluierung liefern, richtig?

Gruß Tom