thread-problem

[gondor]

hallo liebe java-gemeinde!

leider habe ich ein thread-problem. ich möchte gerne einen thread über einen button starten und wieder beenden können. der status, ob der thread laufen oder beendet wird erfolgt über eine checkbox. hier mal ein wenig code:

hier der aufruf:

public void setThreadAutoLog(boolean run_) {

        if (run_) {
            try {
                this.auto_delete_logging = C_AutoDeleteLogging.getInstance();
                System.out.println("STARTEN");
                auto_delete_logging.setInterrupted(false);
                auto_delete_logging.start();
            } catch (Exception ex) {
                /*** Errorhandling ***********************************/
                System.out.println("Error: setThreadAutoLog (Exception)");
                cat.error("Error: setThreadAutoLog (Exception)");
            }
        } else {
            System.out.println("BEENDEN");
            auto_delete_logging.setInterrupted(true);
        }
 }

hier die thread-klasse:

public class C_AutoDeleteLogging extends Thread {

    /*------------------------------------------------------------------*/
    /* Initialisierung*/
    /*------------------------------------------------------------------*/

    /*Logging*/
    Logger cat = (Logger) Logger.getLogger(this.getClass());

    /*LogFile*/
    private C_LogFile logFile = null;

    /*Vergleichsgröße die sagt, ab wann das LogFile gelöscht werden soll*/
    private long deleteSize = 0;

    /*Wie lange soll der Thread inaktiv sein*/
    private long time_to_sleep_in_millis = 1500;

    /*Variable, um Thread zu unterbrechen*/
    private boolean interrupted = false;

    /*Instanz der eigenen Klasse --> SINGLETON-PATTERN*/
    private static C_AutoDeleteLogging INSTANCE;

    /*------------------------------------------------------------------*/
    /* Konstruktoren*/
    /*------------------------------------------------------------------*/

    private C_AutoDeleteLogging() {

        this.logFile = new C_LogFile(C_LogFileConstant.LOG_FILE_FILEPATH);
    }

    public static synchronized C_AutoDeleteLogging getInstance() {
        if (INSTANCE == null) {
            System.out.println("OBJECT gebildet");
            INSTANCE = new C_AutoDeleteLogging();
        } else {
            System.out.println("Schon gestartet...")
        }
        return INSTANCE;
    }

    /*------------------------------------------------------------------*/
    /* Methoden*/
    /*------------------------------------------------------------------*/

    ...

     /**
     * Setzt das Interrupted-Flag, welches für eine Unterbrechung des Threads
     * sorgt.
     * @param interrupted_ Flag
     */
    public void setInterrupted(boolean interrupted_) {

        System.out.println("C_AutoDeleteLogging --> setInterrupted (" + interrupted_ + ")");

        this.interrupted = interrupted_;
    }

    /**
     * Gibt das Interrupt-Flag zurück. Hier kann geschaut werden,
     * ob der Thread noch aktiv ist.
     * @return deleteSize Die Vergleichsgröße
     */
    public boolean isInterrupted() {

        System.out.println("C_AutoDeleteLogging --> isInterrupted");

        return interrupted;
    }

    /**
     * Thread prüft ob das LogFile gelöscht werden darf.
     */
    public void run() {

        System.out.println("C_AutoDeleteLogging --> run");

        while (!isInterrupted()) {

            try {
                /*Schlafen*/
                this.sleep(time_to_sleep_in_millis);

            } catch (InterruptedException ex) {
                /*** Errorhandling ***********************************/
                System.out.println("Error: Automatisches löschen des Log-File (InterruptedException)");
                cat.error("Error: Automatisches löschen des Log-File (InterruptedException)");
                //System.out.println("InterruptedException: " + ex.getMessage());
                //System.out.println("InterruptedExceptionState: " + ex.toString());
                //System.out.println("VendorError: " + ex.getLocalizedMessage());

                setInterrupted(true);
            }

            try {
                /*Überprüfen*/
                System.out.println("Überprüfen");

                if (deleteSize <= logFile.getSize_kB()) {
                    //System.out.println("Inhalt vom Log-File wird gelöscht!");
                    logFile.deleteContent();
                }
            } catch (Exception ex) {
                /*** Errorhandling ***********************************/
                System.out.println("Error: Automatisches löschen des Log-File (Exception)");
                cat.error("Error: Automatisches löschen des Log-File (Exception)");
                //System.out.println("Exception: " + ex.getMessage());
                //System.out.println("ExceptionState: " + ex.toString());
                //System.out.println("VendorError: " + ex.getLocalizedMessage());

                setInterrupted(true);
            }
        }
    }
}

leider klappt das nicht ganz. ich kann den thread starten und auch wieder beenden, aber wenn ich
dann NOCHMAL den thread starten will, ruft er nicht mehr die 'run()' auf. kann mir hier evtl. einer
weiterhelfen?

vielen dank,

 

[meez]

Du musst ein neues Thread Objekt erzeugen.
Nach einem Durchlauf ist ein Thread Objekt immer "verbraucht"..

 

[gondor]

hi meez!

mache ich das denn nicht?

oder muss ich die instanz bei dem stop auf 'null' setzen, damit mir 'INSTANCE = new C_AutoDeleteLogging();' eine neue instanz erzeugt?

gondor(..)

 

[Beni]

Du köntest dein C_AutoDeleteLogging Runnable implementieren lassen:

public class C_AutoDeleteLogging implements Runnable {

Dein Code würde sich dabei fast nicht verändern.

Dann kannst du jederzeit einen neuen Thread mit

C_AutoDeleteLogging auto = ...
new Thread( auto ).start();

starten.

 

[gondor]

@Beni

... scheint zu funktionieren. nur bekomm ich den thread nicht mehr zum 'schlafen'...

die methode sleep konnte ich nicht mehr implementieren. habe diese gegen wait getauscht:

/*Schlafen*/ 
this.sleep(time_to_sleep_in_millis);

mit

/*Schlafen*/
this.wait(time_to_sleep_in_millis);

bekomm ich eine exception:

java.lang.IllegalMonitorStateException: current thread not owner
at java.lang.Object.wait(Native Method)

jemand noch einen tipp?

lieben dank für die hilfe,

gondor(..)

 

[Beni]

Versuch mal "Thread.sleep( ... )", denn sleep ist eine statische Methode.

Das mit dem Monitor kannst du sonst so lösen:

synchronized( this ){
  this.wait( .... );
}

 

[gondor]

alles TOP!

super leute. und wieder eine gute tat vollbracht

gondor(..)

 

[gondor]

ha, doch noch eine frage:

ich habe einen thread, der in zeitabständen die connection zur db überprüft.

dabei möchte ich den status (boolean) nach jeder abfrage auswerten. ausserdem übergebe ich die db-daten dem run:

public boolean run(String user_, String passwd_, String ip_, int port_) {

boolean test_connection = false;
...
test_connection = db.testConnection(user_, passwd, ip_, port_);
...
return test_connection;
}

das, was ich aber möchte ist nicht möglich, oder?
kann ich bei 'run()' was zurückgeben bzw. parameter übernehmen?
wie kann ich das realisieren, wenn ich einen defaultkonstruktor benutze...

geht das nur über setter-methoden?

danke noch einmal für eine 'durchleuchtung'

gondor(..)