Executor

[Hellboy256]

Versuche mich gerade ein bisschen in Threads und dem Executor interface einzuarbeiten und komm bei einem Probelm nicht ganz weiter. Ich moechte einen ThreadPool erzeugen der verschiedene Threads verwaltet. Wenn bei einem Thread ein bestimmtes Ereignis auftritt so soll gewartet werden bis alle anderen Threads beendet sind und dann sollte das Program terminieren. Bisher hab ich sowas:

public class Saver {
        Executor ex = Executors.newCachedThreadPool();

      public void addThread() {
            ex.execute(Handler());
     }
}

public class Handler() implements Runnable {
         
          public Handler() {
               Thread t = new Thread(this);
               t.start();
          }
       
          public void run() {
            //do something
    
           //wenn ereignis eintritt warte bis alle threads beendet
          }
}

 

[Volvagia]

Das ist unnötig. Das Programm terminiert automatisch, sobald alle Nicht-Dämons beendet wurden.
Aber zu deiner Frage:

Der Thread in dem das Event eintritt muss mittels eines Listeners dem Verwalter der Threads (Saver) sagen, dass eben das Event eingetreten ist. Dieser teilt das allen anderen Threads mit, indem er beispielsweiße eine boolean setzt. Die anderen Threads prüfen diese regelmäßig, und wenn sie einen bestimmten Wert hat beenden sie.

 

[Hellboy256]

Sorry hab mich etwas falsch ausgedrueckt es solte so laufen, dass wenn ein Thread ein Ereignis erhaelt dann wartet der Saver bis alle anderen Threads die run()-Methode beendet haben

 

[Volvagia]

Wie wäre es damit? Ist noch immer unklar, da Saver eine Klasse ist und Threads aber keine Klassen warten können. Der Saver-Thread rennt durch, bis im Handler ein Event eintritt (nach etwa 5 Sekunden). Danach wartet Saver, bis die anderen beiden Threads beenden (nach ca. weiteren 5 Sekunden). Danach beendet er selbst. Ist aber nur schnell zusammengetippt.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Saver implements Runnable {
	private static Logger logger;

	private boolean waitForThreadsTerminating;
	private boolean allThreadsTerminated;
	private ExecutorService ex;
	
	
	static {
		logger = Logger.getLogger(Saver.class.getName());
	}
	public Saver() {
        ex = Executors.newCachedThreadPool();
	}
	
	public void startRunnable(Runnable run) {
		ex.execute(run);
	}
	
	public static void main(String[] args) {
		Saver saver = new Saver();
		saver.startRunnable(saver.new Handler());
		
		saver.startRunnable(saver.new OtherThread());
		saver.startRunnable(saver.new OtherThread());
		
		saver.start();
	}
	private void start() {
		Executors.newFixedThreadPool(1).execute(this);
	}

	public void run() {
		do {
			logger.log(Level.INFO, "Saver Durchlauf");
			if(waitForThreadsTerminating) {
				try {
					logger.log(Level.INFO, "Saver wartet auf Threads");
					ex.shutdown();
					ex.awaitTermination(1, TimeUnit.DAYS);
					logger.log(Level.INFO, "Threads wurden beendet");
					allThreadsTerminated = true;
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			
			try {
				TimeUnit.MILLISECONDS.sleep(100L);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} while(!allThreadsTerminated);
		logger.log(Level.INFO, "Saver beendet.");
	}
	
	public class Handler implements Runnable {
		public void run() {
			try {
				TimeUnit.SECONDS.sleep(5L);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
			logger.log(Level.INFO, "Event im Handler aufgetreten.");

			//Ereignis aufgetrehten, Listener aufrufen. In dem Beispiel spaare ich mir die.
			waitForThreadsTerminating = true;
		}
	}
	public class OtherThread implements Runnable {
		public void run() {
			try {
				TimeUnit.SECONDS.sleep(10L);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
			logger.log(Level.INFO, "OtherThread beendet.");
		}
	}
}