Java - Aufteilung der Arbeit auf mehrere threads

Bin ich gestellt mit dem folgenden problem: ich brauche, um die Arbeit aufzuteilen auf mehrere threads für die perfomance-Gründen, aber ich bin nicht sicher, was Ansatz zu nehmen.

Erstens, die Aufgabe würde ich liefern sollte einen Wert zurückgeben und ein parameter. Außerdem die main-Methode (das tun die main-bisschen arbeiten, nicht static main() ) läuft bereits auf einem separaten thread und wird aufgerufen, in regelmäßigen Abständen. Zudem ist diese Methode muss irgendwann WARTEN Sie, bis alle threads fertig und dann gehen.

Einem Ansatz (die meisten offensichtlich für mich) ist, planen Sie jede Aufgabe auf einem separaten thread aus und speichern die Ergebnisse in der Klasse vars:

public Object result1, result2;

public void mainMethod() throws InterruptedException {
    final Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            result1 = expensiveMethod("param1");
        }
    });

    final Thread thread1 = new Thread(new Runnable() {
        @Override
        public void run() {
            result2 = expensiveMethod("param2");
        }
    });

    thread1.join();
    thread.join();

    //Do rest of work
}

private Object expensiveMethod(Object param){
    //Do work and return result
}

Dies ist ein bisschen hässlich und nicht ideal, denn wie ich sagte, mainMethod ist aufgerufen, viele Male, und ich möchte nicht irgendwelche race-conditions auf die Einstellung der Ergebnis-Variablen. Im Idealfall würde ich mag, um Sie lokalen Variablen zu arbeiten, aber ich kann nicht machen Sie Sie zugänglich von innerhalb der run-Methode, es sei denn, Sie sind endgültig, und dann kann ich keine Werte zuweisen, um Sie...

Anderen Ansatz, den ich zwar zu tun hatte, war:

public void mainMethod() throws InterruptedException, ExecutionException {
    String obj1, obj2;

    final ExecutorService executorService = Executors.newFixedThreadPool(16);
    final Future<String> res1 = executorService.submit(new Callable<String>() {
        @Override
        public String call() throws Exception {
            return expensiveMethod("param1");
        }
    });
    final Future<String> res2 = executorService.submit(new Callable<String>() {
        @Override
        public String call() throws Exception {
            return expensiveMethod("param2");
        }
    });

    obj1 = res1.get();
    obj2 = res2.get();

}

private String expensiveMethod(String param) {
    //Do work and return result
}

Diese automatisch wartet auf diese zwei Berechnungen, die von der main-Methode und erlaubt es mir zum speichern der Ergebnisse vor Ort. Was Sie Kerle denken? Andere Ansätze?

  • Mit Future ist eine gute Idee.
InformationsquelleAutor Bober02 | 2012-10-11
Schreibe einen Kommentar