Thread schlafenlegen und später wieder aufwecken

[Gast]

Hallo,

ich habe folgendes Problem: ich will einen Thread erzeugen, der eine gewisse Zeit lang seine Arbeit macht, dann
irgendwann mal unterbrochen wird und zu einem späteren Zeitpunkt seine Arbeit wieder aufnehmen soll.
Jetzt habe ich hier im Forum einen Ansatz gefunden, mit dem das ganze funktionieren sollte. Und zwar hat jemand geschrieben, man soll wait(); und eine boolean-Var. verwenden. Habe leider keine Idee, wie ich das umsetzte..

Vielen Dank für eure Hilfe!

Hier der grobe Aufbau wie ich es mir vorstelle:

public class ThreadTest {

    Thread myThread = new MyThread();
    
    protected void startThread() {       
        /*if (myThread.getState() == Thread.State.WAITING) {
            myThread.???;          hier soll er aufgeweckt werden, aber mit welcher Methode?
        } else myThread.start();  */
    myThread.start();           // das kann ich lt. API ja nur einmal pro thread aufrufen
    }
    
    protected void stopThread() {         
        try {
          myThread.wait();      // geht so noch nicht
        } catch (InterruptedException e) {}                                                             
    }    
    
    private class MyThread extends Thread {
        
        public void run() {           
            while (true) {
                if (isInterrupted()) {                    
                    break;
                }
                this.tuWas();
            }                      
        }
        
        private void tuWas() {
            System.out.println(" arbeite..");
            try {                
                Thread.sleep(500);                
            } catch (InterruptedException e) {                
                interrupt();               
            }
        }   
    }
    
    public static void main(String args[]) {        
        ThreadTest tt = new ThreadTest();
        System.out.println("erster Durchgang..");
        try {
            tt.startThread();
            Thread.sleep(2000);    // thread wird irgendwann unterbrochen
                                             // hier testweise nach 2 sek.                  
        } catch (InterruptedException e) { /* nix */ }
            tt.stopThread();       
        
        // hier wird irgendwas anderes gemacht..
        // zeit vergeht...
            
        // jetzt soll der 'alte' thread wieder aufgeweckt werden
        System.out.println("nächster Durchgang");
        // aber wie ???
    }   
}

 

[Sky]

Vielleicht findest Du die Lösung hier: http://java.sun.com/j2se/1.4.2/docs/guide/misc/threadPrimitiveDeprecation.html

 

[Gast]

perfekt, damit müsste ich es hinbekommen.

danke, sky80!

 

[Gast]

perfekt, damit müsste ich es hinbekommen.

tja, doch nicht ganz so einfach..
Aber das blinker-Beispiel passt genau zu dem, was ich machen will. Ich habe eine Verkehrsampel, die beim Click auf den Button "Blink" anfängt zu blinken. Wenn man wieder auf "Blink" (oder auf "rot", "gelb" oder "grün") klickt, soll das blinken aufhören. Soweit funktioniert es auch schon, doch wenn ich den Blinker erneut starten will, gibts keine Reaktion. Ich habe das mit dem notify(); noch nicht richtig verstanden. Hier ein Auszug des Codes:

//Action-Listener
    public synchronized void actionPerformed(ActionEvent event) {        
        String cmd = event.getActionCommand();        
        
//  hier werden die anderen buttons gechekt, ist unwichtig..
//  ...

} else if (cmd.equals("BLINK")) {                                                
            if (!blinkerGestartet) {   // thread darf nur 1mal gestartet werden
                startBlinking();
            } else if (!blinkerUnterbrochen) { 
                stopBlinking();
            } else if (blinkerUnterbrochen) {                
                    blinkerUnterbrochen = false;
                    notify();     // hier sollte es wieder blinken, geht aber nicht..
            }
        }
    }
        
    private Thread blinker = new Blinker();
    private boolean blinkerGestartet = false;
    private boolean blinkerUnterbrochen = false;

    protected void startBlinking() {                
        blinkerGestartet = true;
        blinker.start();
    }
    
    protected void stopBlinking() {       
        blinkerUnterbrochen = true;        
    }
    
    private class Blinker extends Thread {
        private boolean blink = true;
        
        public void run() {           
                System.out.println("Blinker start");             
                while (true) {
                    try {
                        Thread.sleep(500);
                        blinke();                          
                        synchronized (this) {
                            while (blinkerUnterbrochen)                            
                                    wait();  
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    repaint();
                }                                 
        }
        
        public void blinke() {
            if (blink) {
                amp2.setCol("yellow");
            } else {
                amp2.setCol("");
            }         
            blink = !blink;         
        }
    }

Edit Illuvatar:

sorry, habe das ende tag vergessen

Dann mach keinen neuen Post sondern wart auf nen Mod
*codetags korrigiert, post gelöscht*

 

[Gast]

Hab die Fehler gefunden. Das

synchronized (this)

in der run()-Methode ist falsch.
Ich muss hier sagen

synchronized (blinker)

.
Ich erkläre mir das so, dass ich ja nicht eine Klasse, sondern eine
Instanz dieser Klasse synchronisieren möchte.
Als nächstes muss auch das notify() im Eventhandler in einen synchronized-Block eingefügt werden der ebenfalls das Objekt
enthält welches synchronisiert werden soll -- den blinker!

} else if (blinkerUnterbrochen) {
                    synchronized (blinker) {
                        blinker.notify();
                    }
                    blinkerUnterbrochen = false;

Viele Grüße,
Reinhold