Newsgroup: it.comp.java
Titolo: sospendere l'esecuzione

supponiamo di avere un thread, i metodi che mi interessano sono 2:
la run() compie delle elaborazioni a intervalli di tempo regolari, mettiamo
(per semplicita') che stampi una frase al secondo sullo stout:
public void run()
{
    [...]
    while(true)
    {
        // elaborazione
        sleep(2000);
    }
}
ho semplificato un po' le cose per chiarezza.
Ho poi un altro metodo che dovrebbe fermare temporaneamente l'esecuzione
della run quando prende un comando PAUSE in input (non e' altro che un
intero), e riprendere l'esecuzione dal punto esatto in cui si era fermato
quando gli arriva un comando PLAY.
Quando dico dal punto esatto intendo che se sono entrato in pausa durante
l'attesa, quando riprendo voglio attendere quello che rimane.
avete una qualche idea su come fare?
Io ho provato con wait()/notify() ma non funziona la pausa: si interrompe il
flusso di programma che richiede la pausa, ma la run() continua comegli
pare.
ciao
--
Massimiliano Cialdi
cia...@firenze.net
cia...@control.dsi.unifi.it
cia...@geoide.it

pare.
Scusa, ma ti ho risposto qualche giorno fa!!!???!!! Se c'e' qualche
cosa che non va nel codice dimmela no???
RIPOSTO :
private static final int NUM_MILLIS = <quelli che vuoi>;
private static final int NO_OP = 0;
private static final int WAIT = 1;
...
private int operazione;
...
// Questa la deve chiamare il thread che imposta l'operazione
public synchronized void impostaOperazione(int op)
{    if (operazione != op)
     {    if (operazione == WAIT)
               this.notify();
           operazione = op;
     }
}
// anche private dipende
// Questa la deve chiamare il thread che esegue il run
public void leggiOperazione()
{    int numMillisecondiPassati = 0;
 
     while(true)
     {
     synchronized(this)
     {    do
          {   if (operazione == WAIT)  
              {    try
                   {    this.wait():
                   }
                   catch(InterruptedException e)
                   {    e.printStackTrace();
                   }
              }
              else
              {    // Non c'e' wait
                   this.wait(<numero di millisecondi>);  
                   numMillisecondiPassati += <numero di millisecondi>;
               }
          }while(numMillisecondiPassati < NUM_MILLIS);
     }
     // switch per le altre operazioni, o una soluzione 
     // piu' elegante. 
     numMillisecondiPassati = 0;
     }
}
Se metti <numero di millisecondi> in modo che NUM_MILLIS ne sia
multiplo e' meglio, mi rendo conto che non e' molto elegante, ma
potrebbe andare bene?

pare.
vedi se questo codice ti puo' andare bene
il thread non viene mai interrotto e continua
ad eseguire un polling ogni 50 millisecondi
schedule viene eseguita ogni secondo
e' possibile sospendere e riprendere
con una "risoluzione" di 50 millisecondi
import java.awt.event.*;
import java.awt.*;
public class Demo extends Frame
{
        private boolean pause = false;
 
        private Label label;
        private Thread thread;
        private int time = 0;        
        private Object semaphore;
 
        public Demo()
        {
                semaphore = new Object();
 
                label = new Label();
                Button play = new Button("play/pause");
                setLayout(new GridLayout(2,1));
 
                add(play);
                add(label);
 
                pack();
 
                setSize(200,100);
                setTitle("Demo");                
 
                show();
 
                play.addActionListener(new ActionAdapter());
 
                addWindowListener(new WindowAdapter(){
                        public void windowClosing(WindowEvent e)
                        {
                                System.exit(0);
                        }
                });
        }
 
        public static void main(String args[])
        {
                new Demo();
        }
 
        private class ActionAdapter implements ActionListener
        {
                public ActionAdapter()
                {
                }
 
                public void actionPerformed(ActionEvent e)
                {
                        if (thread == null)
                        {
                                thread = new timerThread();
 
                                thread.start();
                        }
                        else
                        {
                                synchronized (semaphore)
                                {
                                        if (pause)
                                        {
                                                pause = false;
                                        }
                                        else
                                        {
                                                pause = true;
                                        }
                                }
                        }
                }
        }
 
        private class timerThread extends Thread
        {
                private final static int delay = 50;
                private int units = 0;
 
                public timerThread()
                {
                        units = 1000 / delay;
                }
 
                public void run()
                {
                        try
                        {
                                long millis = 0;
 
                                while (!isInterrupted())
                                {
                                        millis = System.currentTimeMillis();
 
                                        if ((time % units) == 0)
                                        {
                                                schedule();
                                        }
 
                                        synchronized (semaphore)
                                        {
                                                if (!pause)
                                                {
                                                  System.out.println("time = " + time % units);
 
                                                        time++;
                                                }
                                        }
 
                                        millis = millis - System.currentTimeMillis();
                                        sleep(delay - millis);
                                }
                        }
                        catch (InterruptedException e)
                        {
                        }
                }
 
                private void schedule()
                {
                        label.setText((time / units) + " secondi");
                }
        }
}
ciao_O
_______________________________________
jame 4.0 is available! 
http://jame.sourceforge.net
_______________________________________
http://digilander.iol.it/schiele

 con una "risoluzione" di 50 millisecondi
Codice FANTASTICO!
volevo chiedere una cosa: compilando il sorgente vengono 4 classi, mentre io
me ne aspettavo solo 3:
che cos'e'  Demo$1.class ?? xche' viene generata??
Scusassi... :-D
Crì



non usare la classe anonima creata quando faccio addWindowListener
(se non ricordo male il mio codice)
ciao_O
_______________________________________
jame 4.0b is available! 
