Threads werden nicht beendet. Was muss dahin?

[Gast]

Hallo,

ich habe folgendes Problem. Ich soll eine java applikation schreiben die primzaheln findet und zwar mit dem sieb des erathostene. So klappt alles suuuuper. aber die abbruchbedingung fehlt. die threads beenden sich am ende einfach nicht was zur folge hat, das die threads super arbeiten auch alles ausgeben aber das programm nicht beendet wird. was soll ich tun?? Hier mal der source:

class Filter extends Thread { // ein Filter ist ein Thread
  private final int N; // dieser Filter repraesentiert die Primzahl N
  private Filter next; // der naechste Filter entlang der Thread-Pipeline
  private ArrayBlockingQueue<Integer> source; // meine Zahlen-Quelle
  private ArrayBlockingQueue<Integer> sink;   // meine Zahlen-Senke
  static final int buflen = 10;

public Filter(ArrayBlockingQueue<Integer> quelle, int n) {
  N = n;
  source = quelle;
  System.out.println(N); // eine neue Primzahl ist gefunden
}
   

  public void run () { // der Lebenslauf jedes Filter-Threads
      while (true) {
      try {
        int n = source.take();
		if(source.size() == 0){interrupt();}
  
        t("gets "+n);
        if (n % N == 0) { continue; }
    
        if (next == null) { // wenn next noch nicht existiert
          sink = new ArrayBlockingQueue<Integer>(buflen); //neuer Queue
	      next = new Filter(sink, n);  // next wird der nächste Thread zugeordnet
	      next.start(); //thread wird gestartet
	    }
  
        try {
          sink.put(n);
        } catch (InterruptedException e) {}
  
      } catch (InterruptedException e) {break;} //erstes try/catch beenden
 
    } 
   }

Hoffe ihr könnt helfen!!!

DANKE!

 

[meez]

Beende das Programm halt mit System.exit()....Oder implementiere eine stopThread() o.ä. Methode, die ein boolean flag auf false setzt while (runthread) {...}

 

[Guest]

wie ? also System.exit.. weis nicht in der aufgabe steht es sollen ALLE threads beendet werden und die while(true) schleife war vorgegeben... könnte ich ein bsp kriegen sitze schon den halben tag drann... das forum is quasie ein anker... sonst häng ich fest ...

 

[meez]

OK hier hab grad einen guten Tag...

SuperKlasse:

public abstract class ThreadHandler extends Thread {

	private static final List threads = new ArrayList();

	public synchronized void register(Thread t) {
		threads.add(t);
	}

	public synchronized void stopAllThreads() {
		for (int n = 0; n < threads.size(); n++) {
			Filter f = (Filter) threads.get(n);
			f.stopThread();
		}
		threads.clear();
	}

	public abstract void stopThread();
}

Deine Klasse mit den veränderten werten:

public class Filter extends ThreadHandler {
	private final int N; // dieser Filter repraesentiert die Primzahl N
	private Filter next; // der naechste Filter entlang der Thread-Pipeline
	private ArrayBlockingQueue source; // meine Zahlen-Quelle
	private ArrayBlockingQueue sink; // meine Zahlen-Senke
	static final int buflen = 10;
	private boolean runThread = true;  // <---------------------------------Added

	public Filter(ArrayBlockingQueue quelle, int n) {
		N = n;
		source = quelle;
		System.out.println(N); // eine neue Primzahl ist gefunden

		super.register(this); // <---------------------------------Added
	}

	public void stopThread() {  // <---------------------------------Added
		runThread = false;    // <---------------------------------Added
		this.interrupt()          // <---------------------------------Added
	}                                     // <---------------------------------Added

	public void run() { // der Lebenslauf jedes Filter-Threads
		while (true) {
			if (!runThread)break;  // <---------------------------------Added
			try {
				int n = source.take();
				if (source.size() == 0) {
					interrupt();
				}

				t("gets " + n);
				if (n % N == 0) {
					continue;
				}

				if (next == null) { // wenn next noch nicht existiert
					sink = new ArrayBlockingQueue(buflen); // neuer Queue
					next = new Filter(sink, n); // next wird der nächste Thread zugeordnet
					next.start(); // thread wird gestartet
				}

				try {
					sink.put(n);
				} catch (InterruptedException e) {}

			} catch (InterruptedException e) {
				break;
			} // erstes try/catch beenden

		}
	}
}

btw. Musste die Generics entfernen...

 

[meez]

Nun kannst du alle stoppen, über jedes Filter Objekt: <filter>.stopAllThreads();

EDIT: Ich Idiot...Ich wollte das eigentlich noch zum letzten Thread hinzueditieren... :roll:

 

[Beni]

Naja, "System.exit" beendet durchaus alle Threads - das Programm geht halt auch gleich zu... :wink:

Ich denke die Reihenfolge der Aufrufe ist falsch: "source.take()" blockiert falls nichts in der Queue ist. Der letzte Thread wird also gar nie bis zu seinem "interrupt()" kommen, da er zuvor auf ein Element wartet.

 

[Guest]

Das ist es!!!!! ER wartet auf sein element!! DAS ISTT ESSSS... danke erstmal für die andere antwort. suuppperr... aba könnte mir bitte jmd helfen mit einem hinweis WIE ich es veranlassen kann das er beendet tortz take() ?? also irgendwie abfange!!!

 

[Beni]

Zuerst

            if (source.size() == 0) {
               interrupt();
            }

... aufrufen, und erst dann "take"? Obs was nützt, weiss ich nicht

 

[Guest]

genau das habe ich versucht.. ( geht nicht....

 

[Guest]

wie terminiere ich das teil?

 

[André Uhres]

wie terminiere ich das teil?

Ich würde vielleicht den try-catch um sink.put(n); herum entfernen,
weil dort eine InterruptedException verschluckt werden kann.

/*
 * ThreadTest2.java
 */
//package thread;
import java.util.concurrent.*;
public class ThreadTest2 {
    public ThreadTest2() {
        source = new ArrayBlockingQueue<Integer>(10);
        source.add(new Integer(1));
        Filter t = new Filter(source);
        t.start();
    }
    private ArrayBlockingQueue<Integer> source; // meine Zahlen-Quelle
    public static void main(String[] args){new ThreadTest2();}
}
class Filter extends Thread{
    public Filter(ArrayBlockingQueue<Integer> source){
        this.source = source;
    }
    public void run(){
        System.out.println("Thread started");
        while(true){
            if(source.size()==0)interrupt();
            try {
                source.take();
            } catch (InterruptedException ex) {
                break;
            }
            System.out.println("OK");
        }
        System.out.println("Thread interrupted");
    }
    private ArrayBlockingQueue<Integer> source;
}

 

[Guest]

hab das jetzt so:

	while (true) {
      try {
        if(source.size() == 0){interrupt();}
		n = source.take();

		
        t("gets "+n);
		
        if(n%N != 0){    
          if (next == null) { // wenn next noch nicht existiert
            sink = new ArrayBlockingQueue<Integer>(buflen); //neuer Queue
	        next = new Filter(sink, n);  // next wird der nächste Thread zugeordnet
	        next.start(); //thread wird gestartet
	      }  

          sink.put(n);
          t("puts "+n);
		}

        }
      catch (InterruptedException e) {break;} //erstes try/catch beenden
 
    }

aber jetzt funktioniert es nur teil weise.. bis 10 terminiert es höher dann nicht mehr.. [/code]

 

[André Uhres]

..bis 10 terminiert es höher dann nicht mehr..

Dann sind sicher nur 10 Threads da.