Threads abschleißen

J

julia123

Erfahrenes Mitglied
hi,
ich bearbeite gerade ein Arbeitsblatt und bruache eure hilfe um weiter machen zukönnen.

Die Aufgabenstellung:
Aufgabe 4 (Beenden von Threads)
(a) Ändern Sie Ihre Lösung aus Aufgabe 1 (oder 2) so ab, dass jetzt das Alphabet nicht nur
einmal ausgegeben wird, sondern beliebig oft.
(b) Führen Sie einen dritten Thread killer ein, mit dem die nicht terminierenden Threads
gross und klein beendet werden: Auf eine Benutzereingabe hin werden die beiden
Threads mit der Methode stop() (deprecated!) beendet.
(c) Ändern Sie Ihre Lösung aus (b), indem Sie jetzt die Threads killer, groß und klein
zusammenarbeiten lassen:
(a) killer verwendet jetzt nicht mehr die Methode stop(), sondern
interrupt(),
(b) groß und klein fragen in ihrer Endlosschleife über die Methode
isInterrupted() ab, ob ein anderer Thread wünscht, dass sie ihre Arbeit
unterbrechen bzw, beenden sollen.
Zum Vergrößern anklicken....

Ich hänge am ersten Punkt (a). Hab jedoch die ganze Aufgabe reingestellt fals weitere Fragen bestehen um nicht noch ein Thema zu erstellen.

Bei der Fragestellung bin ich mir nicht sicher ob das so zu realisieren ist,wie ich es unten gemacht habe.

Code: 
package p;

public class Aufgabe4 extends Thread {

	private boolean gOk;

	public Aufgabe4(String klgr) {

		if (klgr == "klein") {
			this.gOk = true;
		} else {
			this.gOk = false;
		}

	}

	@Override
	public void run() {

		if (gOk == true) {

			for (char c = 'a'; c <= 'z'; c++) {

				System.out.print(c);

			}

		} else {

			for (char b = 'A'; b <= 'Z'; b++) {

				System.out.print(b);

			}
		}

	}

	public static void main(String[] args) {

		int beliebigOft = 2;

		for (int i = 0; i < beliebigOft; i++) { // Ich hab eigentlich nur die Schleife hier hinzugefügt

			Thread klein = new Aufgabe4("klein");
			Thread groß = new Aufgabe4("groß");

			klein.start();
			groß.start();
		}

	}

}
 
Zuletzt bearbeitet:
ok ich glaueb ich hab die (a) auf eine bessere Variante gelöst :

Code: 
package p;

public class Aufgabe4 extends Thread {

	private boolean gOk;
	private int beliebigOft;

	public Aufgabe4(String klgr, int beliebigOft) {

		if (klgr == "klein") {
			this.gOk = true;
		} else {
			this.gOk = false;
		}
		this.beliebigOft = beliebigOft;

	}

	@Override
	public void run() {

		if (gOk == true) {

			for (int i = 0; i < this.beliebigOft; i++) {
				for (char c = 'a'; c <= 'z'; c++) {

					System.out.print(c);

				}
			}

		} else {
			for (int j = 0; j < this.beliebigOft; j++) {
				for (char b = 'A'; b <= 'Z'; b++) {

					System.out.print(b);

				}
			}
		}

	}

	public static void main(String[] args) {

		Thread klein = new Aufgabe4("klein", 2);
		Thread groß = new Aufgabe4("groß", 1);

		klein.start();

		groß.start();

	}

}

Wie ich die (b) machen soll da fehlt mir die Idee glaub ich...
 
Zuletzt bearbeitet:
Hi
Ich würde die Strings im Konstruktor auf jeden Fall mit equals vergleichen da der Vergleich sonst immer false liefern wird.
Java: 
if (klgr.equals("klein")) {
..}

Für b)
Einfach einen neuen Thread erstellen welcher die die vorherigen beiden mit übergeben bekommt und bei einer Eingabe des Benutzers
Java: 
groß.stop();
aufruft und diesen dann beendet.

Lg hendl
 
Ich würde einfach eine neue Klasse erstellen die von Thread erbt und im Konstruktor die beiden vorher erstellten Threads mitübergeben bekommt.
Java: 
public class StopThread extends Thread {
 
    private Thread t1;
    private Thread t2;
 
    public StopThread(Thread klein, Thread groß) {
      this.t1=klein;
      this.t2=groß;
    }
 
}
 
ok,

ich hab das jetzt so noch in die classe eingefügt:
Code: 
@Override
	public void run() {
		t1.stop();
		t2.stop();
	}

und so füre ich das ganze dann aus:

Code: 
public static void main(String[] args) {

		Thread klein = new Aufgabe4("klein", 3);
		Thread groß = new Aufgabe4("groß", 2);
		Thread killer = new StopThread(klein, groß);

		klein.start();
		
		groß.start();

		killer.start();
	}

Ist dass so gewollt?
 
Ich hätte es schon so gelöst.
Wobei die anderen beiden Threads erst durch eine Usereingabe gestoppt werden sollen.

Java: 
public static void main(String[] args) {
        Thread klein = new Aufgabe4("klein", 3);
        Thread groß = new Aufgabe4("groß", 2);
        Thread killer = new StopThread(klein, groß);

        klein.start();
        groß.start();
        Scanner sc = new Scanner(System.in); // Usereingabe lesen, falls stop eingegeben wird, werden Threads beendet
	    String bef=sc.next();
        if(bef.equals("stop"))
            killer.start();
    }
 
ok und jetzt kommt die letzte Aufgabe :



teil c) ->(a)
Code: 
public class InterruptThread extends Thread {

	private Thread t1;
	private Thread t2;

	public InterruptThread(Thread klein, Thread groß) {
		this.t1 = klein;
		this.t2 = groß;
	}

	@Override
	public void run() {
		t1.interrupt();
		t2.interrupt();
	}

}



teil c ) (b)
Code: 
public class Aufgabe4c extends Thread {

	private boolean gOk;
	

	public Aufgabe4c(String klgr) {

		if (klgr.equals("klein")) {
			this.gOk = true;
		} else {
			this.gOk = false;
		}


	}

	@Override
	public void run() {

		if (gOk == true) {

			while (true) {
				for (char c = 'a'; c <= 'z'; c++) {

					System.out.print(c);
					isInterrupted();

				}
			}

		} else {
			while (true) {
				for (char b = 'A'; b <= 'Z'; b++) {

					System.out.print(b);
					isInterrupted();

				}
			}
		}

	}

	public static void main(String[] args) {

		Thread klein = new Aufgabe4c("klein");
		Thread groß = new Aufgabe4c("groß");
		Thread killer = new InterruptThread(klein, groß);

		klein.start();

		groß.start();

		Scanner sc = new Scanner(System.in); 
		String bef = sc.next();
		if (bef.equals("stop"))
			killer.start();
	}

}

Passt das so?

stop() -> löscht ja im grunde denn Thread.

Aber dieses interrupte(), versteh ich nicht ganz. Dass da was gesetzt wird ....
 
Zuletzt bearbeitet:
Hi
Zum stop(): Die Methode stop() sollte nicht mehr verwendet werden, da sie den Thread sofort ohne irgendwelche noch notwendigen Operationen zu tätigen beendet. Bsp. wäre Streams schließen oder ähnliches

interrupt(): Im Thread Object wird ein Flag true gesetzt, dieses kann intern in der run() überprüft werden und es können noch zum Beenden notwendige Operationen durchgeführt werden.
Dieses Flag sollte immer über die Methode isInterrupted() abgerufen werden, da die Methode interrupted() das Flag nach dem Aufruf auf false zurücksetzt und es bei isInterrupted() erhalten bleibt.

Java: 
public class Aufgabe4c extends Thread {

	private boolean gOk;

	public Aufgabe4c(String klgr) {

		if (klgr.equals("klein")) {
			this.gOk = true;
		} else {
			this.gOk = false;
		}

	}

	@Override
	public void run() {

		if (gOk == true) {

			while (!isInterrupted()) { // Hier gibt es 2 Möglichkeiten wie der Thread beendet werden kann; Hier die erste; solange die while Schleife aus
									   // Solange Thread sich nicht beenden soll
				for (char c = 'a'; c <= 'z'; c++) {
					System.out.print(c);
				}
			}

		} else {
			while (true) {
				for (char b = 'A'; b <= 'Z'; b++) {
					System.out.print(b);
					if (isInterrupted()) // 2. Möglichkeit Thread unendlich lange ausführen und wenn sich Thread beenden soll aus Schleife springen;
						break;
				}
				
//				while (true) { // Wobei es eigentlich noch eine dritte Möglichkeit gäbe falls im Thread gewartet wird
//					for (char b = 'A'; b <= 'Z'; b++) {
//						System.out.print(b);
//						try {
//							Thread.sleep(10);
//						} catch (InterruptedException e) {// InterruptedException wird geworfen wenn Thread.interrupt() aufgerufen wird; falls im Thread
//							// gewartet wird
//							break; // Wird in der InterruptedException aus der Schleife gesprungen
//						}
//					}
			}
		}

	}

	public static void main(String[] args) {

		Thread klein = new Aufgabe4c("klein");
		Thread groß = new Aufgabe4c("groß");
		Thread killer = new InterruptThread(klein, groß);

		klein.start();

		groß.start();

		Scanner sc = new Scanner(System.in);
		String bef = sc.next();
		if (bef.equals("stop"))
			killer.start();
	}
}

class InterruptThread extends Thread {

	private Thread t1;
	private Thread t2;

	public InterruptThread(Thread klein, Thread groß) {
		this.t1 = klein;
		this.t2 = groß;
	}

	@Override
	public void run() {
		t1.interrupt();
		t2.interrupt();
	}

}
 
ok, cool bis dahin danke erst mal !
Eine Problem hab ich noch bei der 2 Möglichkeit. Da springt er ja nur aus der for- Schleiefe. Also wird diese dannach sofort wieder augeführt oder seh ich das falsch?

Wäre dass nicht so besser oder richtig ? :

Code: 
while (true) {
				for (char b = 'A'; b <= 'Z'; b++) {
					if (isInterrupted()) 
						break;
                                        System.out.print(b);
				}

Ich hab wahrscheinlich ein denk Fehler.
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück