Thread läuft und läuft, trotz interrupt()

[chamaeleon879]

Ich habe irgendwie Probleme mit der Thread Programmierung (muss zugeben bin hier auch grad am Anfang)

das ZIEL: Ich habe ein Programm geschrieben, welches am Anfang einen Verzeichnisbaum einließt. diese einlesen dauert je nach dem unterschiedlich lange. Und um dem Anwender zu "zeigen", dass das Programm noch läuft, soll ein Info-Fenster erscheinen.

So nun hier mal der Code:

   public List initProgressbarList(){
   Runnable initialisierungsFenster = new Runnable() {
   public void run() {
   m.meldungAnzeigen(m.INITIALISIERUNG_TYPE);
   }
   };
        
        Thread t = new Thread(this.getThreadGroup(),initialisierungsFenster, "Fenster");
        t.start();
        List listTemp1 = new ArrayList();
        List listTemp2 = new ArrayList();
        listTemp1 = initialisiereTree(filesourceObjekt.listFiles());
        listTemp2 = initialisiereTree(filedestinationObjekt.listFiles());
        
        
        
        if (listTemp1.size()>=listTemp2.size()){
            this.auswahl = 1;
            t.interrupt();    
            System.out.println(t.interrupted());
            return listTemp1;
        }
        else {
            this.auswahl = 2;
            t.interrupt();
                System.out.println(t.interrupted());
            return listTemp2;
        }
        
        
    }

Also der Aufruf der Methode funktioniert, auch in einem eigenen Thread. Aber wie gesagt, wird er nicht unter brochen.
Irgendwie funzt das t.interrupt() nicht. Bei der Überprüfung (t.interrupted()) erscheint false

anbei poste ich auch mal die Mehtoden die Aufgerufen werden in der "run" Methode

    public void meldungAnzeigen(int messageType){
        switch (messageType){
            case 1:{
            JOptionPane pane = new JOptionPane();
            pane.setMessageType(pane.INFORMATION_MESSAGE);
            pane.showMessageDialog(null,"Synchronisation Erfolgreich");
            break;
            }
            case 2:{
            JOptionPane pane = new JOptionPane();
            pane.setMessageType(pane.ERROR_MESSAGE);
            pane.showMessageDialog(null,"Synchronisationen ist fehlgeschlagen\n" +
                    "bitte ErrorProtokoll einsehen");
            break;
            }
            case 3:{
                 InitialisierungDialog initMessage = new InitialisierungDialog();
                 initMessage.setVisible(true);
            break;
            }            
        }
    }

bei meldungAnzeigen wird 3 übergeben, es wird also das Opjekt InitialisierungDialog() instanziert. hier dazu der Code:
(Ist aber nur Standard NetbeansCode vom Gui Editor, also eigentlich nix besonderes und sollte den Thread nicht beeinflussen.

/*
 * initialisierung.java
 *
 * Created on 26. Dezember 2006, 14:47
 */

package Gui;

/**
 *
 * @author  Reichel
 */
public class InitialisierungDialog extends javax.swing.JFrame {
    
    /** Creates new form initialisierung */
    public InitialisierungDialog() {
        initComponents();
    }
    
    /** This method is called from within the constructor to
     * initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is
     * always regenerated by the Form Editor.
     */
    // <editor-fold defaultstate="collapsed" desc=" Generated Code ">                          
    private void initComponents() {
        jButton1 = new javax.swing.JButton();
        jProgressBar1 = new javax.swing.JProgressBar();
        jLabel1 = new javax.swing.JLabel();
        jLabel2 = new javax.swing.JLabel();

        jButton1.setText("jButton1");

        setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
        setTitle("Initialisiere");
        setCursor(new java.awt.Cursor(java.awt.Cursor.WAIT_CURSOR));
        setEnabled(false);
        setResizable(false);
        setUndecorated(true);
        jProgressBar1.setIndeterminate(true);

        jLabel1.setFont(new java.awt.Font("Arial Rounded MT Bold", 0, 14));
        jLabel1.setText("Initialisierung lauft");

        jLabel2.setFont(new java.awt.Font("Arial Rounded MT Bold", 1, 11));
        jLabel2.setText("Bitte Warten Sie...");

        org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
            .add(layout.createSequentialGroup()
                .addContainerGap()
                .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.TRAILING, false)
                    .add(org.jdesktop.layout.GroupLayout.LEADING, jProgressBar1, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                    .add(org.jdesktop.layout.GroupLayout.LEADING, jLabel2, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                    .add(org.jdesktop.layout.GroupLayout.LEADING, jLabel1, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
                .addContainerGap(org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
            .add(layout.createSequentialGroup()
                .addContainerGap()
                .add(jLabel1)
                .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED)
                .add(jLabel2)
                .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED)
                .add(jProgressBar1, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE)
                .addContainerGap(org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
        );
        pack();
    }// </editor-fold>                        
    
    /**
     * @param args the command line arguments
     */

    
    // Variables declaration - do not modify                     
    private javax.swing.JButton jButton1;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JLabel jLabel2;
    private javax.swing.JProgressBar jProgressBar1;
    // End of variables declaration                   
    
}

kann mir hierzu jemand helfen ?

 

[Waldbeere]

Hiho,

es gibt in der Klasse Thread die 2 Methoden: interrupt() und isInterrupted()
Diese 2 Methoden tun nichts anderes als ein flag setzen bzw. prüfen ob es gesetzt wurde.
Du musst dich selbst darum kümmern das der Thread dann korrekt beendet wird. Sprich
Du hast eine Schelife in der Du immer überprüfst ob das unterbrechen-Flag (isInterrupted())
gesetzt ist, falls ja brichst du den die Schleife ab und beendest den Thread. Der Sinn da hinter
ist der das du, wenn Du von aussen einen thread beenden würdest, würdest Du nicht wissen an
welcher Stelle der Thread gerade ist du könntes tin an einer kritischen Stelle einfach so abschiessen.
Um dies zu verhindern soll der Thread selbst entscheiden wann er sich beenden darf.
Einzelheiten fidnest Du hier

Edit:
Huch und wie ich das gerade noch sehe macht das nicht wirklich viel Sinn den Thread
überhaupt unterbrechen zu wollen, der arbeitet ja seine funktion durch in der run Methode und
ist dann zuende. Also benutzen kannst Du das erst sinnvoll, wen nes was zu unterbrechen gibt,
also wenn du z.B in ner Schelife ganze Zeit läufst.


Gruss Waldbeere

 

[chamaeleon879]

also ich hatte mir das Tutorial im Forum mal angesehen, dachte aber, dass das mit der endlos Schleife nur Zufall ist.
hmm konkret müsste das ja dann heißen, dass ich eigentlich keinen thread brauche ?!?!

dann müsste es eigentlich ja wie folgt funktionieren:

private void Methodenname(){

FensterMeldungAnzeigen.setVisible(true);


tue Irgend etwas wie beispielsweise einen Dateipfad initialisieren


FensterMeldungAnzeigen.setVisible(false);
}

Probiere das gleich mal aus.

Vielen Dank erstmal!!!!

 

[chamaeleon879]

hmmm also so wie ich mir das vorgestellt habe läuft das ganze leider nicht ;-(.
Ich muss das Statusfenster über einen eigenen Thread starten damit es angezeigt wird.

Das einzige was mir ein wenig widestrebt ist, dass ich dann bei der Initialisierung des Fensters eine Endlosschleife laufen lassen muss, die auf das Interrupt Flag reagiert. Braucht das denn nicht unmengen an Systemressourcen???

Ich hätte ja den gleichen Effekt, wenn ich eine final static Variable ständig auf deren Zustand überprüfe.
Also irgendwie widerstrebt mir das...

Es hat doch bestimmt schon mal jemand von euch ein Statusfenster programmiert, in dem der Anwender nur dauraufaufmerksam gemacht wird, dass eine Aktion im Hintergrund läuft. Wie gebt ihr denn dem Statusfenster "bescheid", dass es verschwienden soll wenn es in einem eigenen Thread läuft ?

 

[nocxsville]

Naja das ist eigentlich unabhängig vom Thread. du kannst ja folgendes machen:

final JDialog dialog = new StatusDialog();

final Thread showDialogThread = new Thread() {
   public final void run() {
      dialog.setVisible(true);
   }
}

showDialogThread.start();

// Aktionen durchführen und aktuellen Status auf Dialog anzeigen

dialog.dispose();

Gruß,
nocxsville.

 

[chamaeleon879]

hmm also das funzt leider nicht... ich werde noch wahnsinnig.
Jetzt wird zwar ein Fenster angezeigt, diese ist aber nur grau. Das Fenster wird erste dann korrekt angezeigt, wenn ich wieder bei initMessage.setVisible(false); bin. Würde ich also das setVisible und dispose weglassen, würde das fenster dann korrekt angezeigt werden. Aber ich brauche eben diese Fenster um gerade die "initProgressbarList()" zu überbrücken bzw. anzuzeigen das der Rechner nicht abgestürzt ist.

Es sieht irgendwie so aus, als ob das Fenster nicht gerendert werden kann. Allerdings hätte ich jetzt mal gedacht, dass ich genau dafür einen neuen thread auf mache.


ich poste mal den Code:

private void jButtonsynchronisierenActionPerformed(java.awt.event.ActionEvent evt) {                                                       
final InitialisierungDialog initMessage = new InitialisierungDialog();
        
            Runnable initialisierungsFenster = new Runnable(){
              public void run(){
                  initMessage.setVisible(true);
              }  
            };

        Thread t = new Thread(initialisierungsFenster);
        t.start();
        sync synchronisation = new sync(var,this);
        Thread syncThread = new Thread(synchronisation);
        max = synchronisation.initProgressbarList().size();
        jProgressBarSyncFortschritt.setMaximum(max);
        initMessage.setVisible(false);
        initMessage.dispose();

        syncThread.start();
        
    
    
    }

 

[Waldbeere]

Hi,

also ich kramm den Thread mal wieder aus der versenkung hoch. Also, im moment macht die
run Methode so wie Du sie da im Moment stehen hast zu der oben genannten Aufgabe nicht viel Sinn.
Du willst ja dem Benutzer irgend wie eine Rückmeldung geben solange der Verzeichnisbaum
eingelsen wird. Deine run Methode und damit der Thread machen im Moment nichts anderes als
das Dialog Fenster sichtbar, danach ist der Thread zuende. Wenn Du irgendwie kontinuirlich dem
Benutzer ein Feedback geben willst, musst du auch irgendwie kontinuirlich (die ganze Zeit) etwas
abfragen. Also:

public void run() {
    while(verzeichnisbaum wird noch erstellt bzw. Thread ist unterbrochen?) {
        Zeige aktuellen Status
    }
}

In deinem Hauptprogramm erstellt dann gemütlich deinen Verzeichnisbaum, und wenn dies beendet
ist, rufst Du ein interrupt auf damit der Thread selbst darauf reagieren kann. und seine Schleife abbricht.
Zu der Frage ob so eine Endlosschleife nicht resourcenfressend ist kann man sagen, dass ein Thread
ja nicht immer aus Endlosschleifen aufgebaut sein muss. Ein Thread dient ja dazu rechenintensive
Operationen quasi paralel laufen zu lassen, genau damit das Hauptprogramm nicht ausgebremst wird,
aber wenn Du etwas hast das die ganze Zeit dem Benutzer ein Feedback geben soll, wie z.B
---> Suche im Verzeichnis xy
---> Suche im Verzeichnis xy/wq
dann musst du naürlich auch die ganze Zeit etwas abfragen. Sollte dein Dialog-Fenster nur anzeigen
erstelle Verzeichnisbaum ohne Animation oder sonst was, brauchst Du auch keinen Thread. Dann
erstellst Du einfach vor dem Verzeichnisbaum das Fenster machst es sichtbar und nach dem erstellen des
Baumes entfernst Du es wieder.

Gruß Waldbeere

 

[chamaeleon879]

Leider geht genaus das

Sollte dein Dialog-Fenster nur anzeigen
erstelle Verzeichnisbaum ohne Animation oder sonst was, brauchst Du auch keinen Thread. Dann
erstellst Du einfach vor dem Verzeichnisbaum das Fenster machst es sichtbar und nach dem erstellen des
Baumes entfernst Du es wieder.

nicht

Also meiner Meinung nach ist das Problem viel zu simpel um dass es existieren dürfte.
Bisher läuft es bei mir (und bei euch ja eigentlich so ab) ihr habt die Haupt GUI mit irgendwelchen Buttons.
Wenn man nun auf einen Button klickt und beispielsweise folgenden Code hat:

neuesFensterle fenschter = new neuesFensterle();
fenschter.setVisible(true);

dann erstrahlt das Fenster das licht der Welt.

Nun habe ich folgendes vor.
Wenn ich auf einen Button klcike, soll ein fenster erscheinen wie meine "fenschter" s.o. NACH dem aufbauen des fesnters wird der Code einfach weiter ausgeführt und dann wenn ich es will, kommt die mehtoder setVsisible(false);
DAs Fenster soll überhaupt nicht in irgendeinerweise Statusinformationen von den auszuführenden Methoden erhalten. es soll einfach nur am Bildschirm stehen und nett aussehen.

Das Problem ist jetzt folgendes:

Ich rufe über einen Butten die Methode.setVisible(true) auf. Wenn ich das ganze ohne Threads laufen lasse also einfach wie oben

neuesFensterle fenschter = new neuesFensterle();
fenschter.setVisible(true);

erscheint ersmal nix!!, UND mein Pfad wird initialisiert (was ca. 2-3 sek dauert). DANACH erscheint erst das Fenster!!!!!
Aber das Dumme ist, das Fenster soll ja gerade den initialisierungsvorgang überbrücken.

Wenn ich das ganze (wie oben geposted) über einen eigenen Thread laufen lasse, erscheint zumindest vor der initialisierung der Rahmen des Fensters. Das vollständige Fenster erscheint aber auch erst nach der initialisierung.

 

[Waldbeere]

Hossa,

also ich hab mich mal selbst ran gemacht, hab dann beim
benutzen vom JDialog gemerkt wo das Problem ist, falls Du den auch benutzt?
Daher das wenn der Dialog modal ist das ganze Fenster dann stehen bleibt ist das schon richtig mit
dem Thread wie Du ihn hattest, ich habs so gemacht:

package main;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;

public class Test extends JFrame implements ActionListener{
	
	public static void main(String[] args) {
		Test myWindow = new Test();
		myWindow.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		myWindow.setSize(320, 240);
		myWindow.setVisible(true);
	}
	
	private JButton myButton;
	private JDialog myStatus;
	
	public Test() {
		myButton = new JButton("Drücken");
		myButton.addActionListener(this);
		myButton.setActionCommand("drück");		
		add(myButton);
		
		myStatus = new JDialog();
		myStatus.setSize(150, 80);
		myStatus.setModal(true);
		myStatus.setVisible(false);		
	}

	public void actionPerformed(ActionEvent e) {
		if ("drück".equals(e.getActionCommand())) {						
			new Thread(new Runnable () {
				
				public void run() {		
					//Tue irgendwas und setze danach den JDialog auf visible == false 					
					for (int i = 0; i < 100000; i++) {
						System.out.println("Durchlauf: "+i);
					}				

					myStatus.setVisible(false);
				}
			}).start();
			
			myStatus.setVisible(true);
		}
	}	
}

Edit: Also Du musst den Thread starten bevor der JDialog sichtbar wird, und im Thread machst Du ihn wieder
unsichtbar.

Gruß Waldbeere

 

[chamaeleon879]

klingt eigentlich ganz einfach *g probiers gleich mal aus.Merci