meinThread.wait(); wirft immer Exeption & hat kein Effekt

[T_Wolf]

Hi also ich habe einen Thread, und eine GUI in der ich in Buttons den Thread starte und warten lassen will und wieder anwerfen. Allerdings ist der thread weder zu stoppen noch schlafenzulegen.

Wenn ich selbst einen Boolean erstelle welcher wenn true intern .stop() aufruft klappt es aber warum kann ich wait() stop() notify() nicht von außen aufrufen .... Was habe ich da nicht verstanden ?



Thread :

	public void run (){
		
		for (int i=0;i<irgendwann;i++){
			this.machezeug();
			if (kontrolliertesBeenden)this.stop();  // Teil der funktionierenden Lösung
		    try
		    {
		    	Thread.sleep(100);
		    }
		    catch (InterruptedException ie)
		    {
		        System.out.println("Exeption beim schlafen!");
		    }
		}
	}

Buttons (dooferThread ist ausserhalb erstellt) :

        startSim = new JButton("Simulation starten");
        getContentPane().add(startSim);

        startSim.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
        		dooferThread.start();
            }
        });
        
        anhalten = new JButton("Simulation anhalten");
        anhalten.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
            	refresher.cancel(true); 
        		try {
                	fermenterThread.kontrolliertesBeenden=true;  // Das funktioniert ist aber sicherlich nicht so gedacht das man sich die Methoden selbst reinhauen muss zum abbrechen
                	dooferThread.wait();
        		} catch (Exception ignore) {
        			System.out.println("Fehler, dies könnte ein Fehler sein.");
        		}
            }
        });

 

[faetzminator]

Wird eine [c]IllegalMonitorStateException[/c] geworfen? Kann gut sein, denn:

Throws:
IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.

 

[Michael...]

wait() muss an einem gemeinsamen Objekt aufgerufen werden, auf dessen Zugriff gewartet werden soll - nicht am Thread
s. API Doku:
Object#wait()

 

[Beni]

Und "Thread.stop" sollte man nicht aufrufen. Das ist eine uralte Methode die üble Nebeneffekte hat. Es ist besser einfach die run-Methode zu verlassen, dann beendet sich der Thread von alleine.

 

[T_Wolf]

Wird eine [c]IllegalMonitorStateException[/c] geworfen? Kann gut sein, denn:

Ja genau die wird geworfen.
Aber benötige doch 2 Buttons um die zu kontrollieren eine zum starten und einen zum abbrechen. und deklariert habe ich das Ding ausserhalb (wie es bei Variablen bisher immer geklappt hat.
oder was muss ich hier anders machen ?

@ Michael ... es gibt keine gemeinsamen Objekte ... der Thread erstellt nur Daten welche in ner Datenbank gespeichert werden -> die gui greift nur auf die Daten der Datenbank zurück

@Beni
Quasi ist das stop bisher nur platzhalter für die Methode die ich dann nutzen werde, allerdings hat keine funktioniert.
.cancel() wäre die "neuere" variante oder ?

 

[faetzminator]

.cancel() wäre die "neuere" variante oder ?

Du sollst manuell eine Abbruchbedingung implementieren. Z.B. kannst du einen boolean definieren, welcher über ein Setter auf false gesetzt wird, und solange dieser true ist, mit deinen Arbeiten in [c]run()[/c] fortfahren.

 

[SlaterB]

wait() ist nicht einfach eine Thread-Methode wie start() oder stop() (ungeachtet ob letzte überhaupt funktioniert),
sondern eine der wenigen Methoden die von Object geerbt werden,

den Einsatz von wait und notify muss man erst lernen, hat mit Synchronisation zu tun
Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 11.6 Synchronisation über Warten und Benachrichtigen
besonders
> 11.6.3 Warten mit wait() und Aufwecken mit notify()

am besten natürlich das ganze Kapitel 11 von Anfang an lesen und noch 'am besteren' die vorherigen kennen

 

[Gastredner]

Quasi ist das stop bisher nur platzhalter für die Methode die ich dann nutzen werde, allerdings hat keine funktioniert.
.cancel() wäre die "neuere" variante oder ?

Nein. Stattdessen konstruiert man die run()-Methode des Threads so, dass sie sich irgendwann alleine beendet, also sozusagen ausläuft. Der Thread beendet sich nach Auslaufen der Methode dann von selbst.

(Unsinniges) Beispiel:

public class SelfEndingThread {

	public static void main(String[] args) {
		Runnable runnable = new Runnable() {
			
			public void run() {
				for (int i=0; i<=10; i++) {
					System.out.println(i);
				}
				// Es folgt keine weitere Anweisung - die Methode beendet
				// sich. Der Thread wird ihr dann automatisch folgen.
			}
		}
		new Thread(runnable).start();
	}
}

 

[T_Wolf]

@ Faetzeminator

So etwas habe ich ja Quasi mit dem Bool "kontrolliertesbeenden" getan, die .stop wird im thread zu einem Zeitpunkt aufgerufen wo nichts kaputtgehen kann.

@ Slater
werde ich dan mal lesen und verstehen müssen

@Gastredner

Allerdings kostet es doch enormen Rechenaufwand jeden durchlauf ein neuen Thread zu erstellen (der Thread an sich hat einiges an Variablen & Methoden

 

[Michael...]

Allerdings kostet es doch enormen Rechenaufwand jeden durchlauf ein neuen Thread zu erstellen (der Thread an sich hat einiges an Variablen & Methoden

Wäre aber eine einfach umzusetzende Möglichkeit - und Rechenaufwand wird oft überschätzt.

Mit wait() und notify() könnte man den Thread anhalten. Allerdings muss das - wie gesagt - an einem gemeinsamen Objekt aufgerufen werden. Wenn's kein sinnvolles gemeinsames Objekt gibt könnte man sich eines zu diesem Zweck eines erzeugen.

 

[SlaterB]

also wenn der Thread selber kein gemeinsames Objekt ist (zwischen Thread und seinem Herren), was denn dann?

 

[Michael...]

;-) Kann man durchaus machen - fände ich allerdings nicht so schön, zumal der Thread ja auf etwas warten soll und nicht etwas auf den Thread.

 

[T_Wolf]

also wenn der Thread selber kein gemeinsames Objekt ist (zwischen Thread und seinem Herren), was denn dann?

Ja aber wenn es auf dem Thread ausgeführt werden kann müsste
Thread.wait();
Doch funktionieren.
Und warum hat der Programmteil der den Thread startet keine Zugriffsrechte auf den Thread ?

 

[Michael...]

Das wait() muss innerhalb der run-Methode aufgerufen werden, den schließlich soll diese ja pausieren.
hier mal ein auf die Schnelle zusammengeschustertes Bsp.:

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class AnimationWait extends JFrame {
	public static void main(String[] args) {
		new AnimationWait();
	}

	private JButton start, stop;
	private AnimationPanel aniPanel;

	public AnimationWait() {
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setBounds(0, 0, 200, 200);
		this.setLocationRelativeTo(null);
		this.getContentPane().add(aniPanel = new AnimationPanel(),
				BorderLayout.CENTER);
		JPanel panel = new JPanel(new GridLayout(1, 2));
		panel.add(start = new JButton("Start"));
		panel.add(stop = new JButton("Stop"));
		this.getContentPane().add(panel, BorderLayout.SOUTH);
		this.setVisible(true);
		
		new Thread(new AnimationThread(aniPanel)).start();
		
		start.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent evt) {
				aniPanel.setActive(true);
			}
		});
		
		stop.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent evt) {
				aniPanel.setActive(false);
			}
		});
	}

	class AnimationPanel extends JPanel {
		private Color[] color = new Color[] { Color.RED, Color.BLUE, Color.ORANGE };
		private int colorIndex = 0;
		private boolean active = false;

		public void increaseIndex() {
			colorIndex++;
			this.repaint();
		}
		
		public synchronized void setActive(boolean b) {
			this.active = b;
			this.notifyAll();
		}
		
		public synchronized boolean isActive() {
			return active;
		}

		public void paintComponent(Graphics g) {
			super.paintComponent(g);
			g.setColor(color[colorIndex % color.length]);
			int w = this.getWidth(), h = this.getHeight();
			g.fillRect((w - 50) / 2, (h - 50) / 2, 50, 50);
		}
	}

	class AnimationThread implements Runnable {
		private AnimationPanel panel;
		public AnimationThread(AnimationPanel panel) {
			this.panel = panel;
		}
		
		public void run() {
			while (true) {
				if (panel.isActive())
					panel.increaseIndex();
				else
					try {
						synchronized(panel) {
							panel.wait();
						}
					} catch (InterruptedException exc) {
						exc.printStackTrace();
					}
				try {
					Thread.sleep(200);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

Auf entsprechende Literatur wurde ja schon hingewiesen.

 

[SlaterB]

Ja aber wenn es auf dem Thread ausgeführt werden kann müsste
Thread.wait();
Doch funktionieren.
Und warum hat der Programmteil der den Thread startet keine Zugriffsrechte auf den Thread ?

wie gesagt: völlig am Sinn von Synchronisation allgemein und wait()-Methode im besonderen vorbei,
einfache deutliche Beispiele und Erklärungen im Lehrbuch lesen oder die freundlicherweise hier eintippten Kopien davon

 

[Michael...]

Und warum hat der Programmteil der den Thread startet keine Zugriffsrechte auf den Thread ?

Hat er schon. Aber er hat u.U. zum Zeitpunkt des Aufrufs nicht unbedingt Zugriff auf den Monitor des Objekts.