Früher(:tm:) war es kompliziert eine Aufgabe an einen Thread zu delegieren, wenn man auch noch ein Ergebnis haben wollte. Da brauchte man ein Runable Objekt und das Ergebnis musste auch irgendwo abgelegt werden dann mußte man auch noch auf die Threads warten...

Heute:

• Man legt sich ein Callable<T> an, das nur eine Methode implementiert. T call()
• Erzeugt einen ExecutorService dem sollte man tunlichst sagen, wie viele Threads man gedenkt zu starten, man kann auch einen nehmen, dann werden alle Threads brav hintereinander gestartet.
• Man übergibt sein Callable mittels submit() an den Service und bekommt ein Future<T> Objekt zurück.
• Dann geht man bei und fragt das Future Objekt nach seinem Wert per T get()

 class MyThread? implements Callable<String> {
   @Override 
   public String call() throws Exception {
      // Mach hier was wichtiges im Thread
      return "Ergebnis";
   }  
 }

 @Test

public void testMyThread() {

   ExecutorService? executor = Executors.newFixedThreadPool(1);
   Future<String> future = executor.submit(new MyThread?());
   String value = future.get();
   executor.shutdown();

   Assert.assertEquals("Ergebnis", value);
 }

Schon läuft das MyThread Objekt im eigenen Thread. Die future.get() wartet so lange, bis die Funktion call() zurückkommt. Das ist alles.

Das geht mit beliebig vielen Objekten, na schön, irgendwann gibt irgendetwas auf...