Newsgroup: it.comp.java
Titolo: metodo stop() deprecato

Dato che il metodo in oggetto è deprecato, come lo fermo il thread !?!? Non
ho visto nulla nei docs dell'SDK 1.4xx a parte stop() (parlo della classe
Thread ovviamente)


Nella documentazione della stop stessa e' *chiaramente* indicato come si 
fa a sostituire la stop stessa.
Leggi 
http://java.sun.com/j2se/1.4.1/docs/api/java/lang/Thread.html#stop()
Ricopio (se sei troppo svogliato e non vuoi seguire il link indicato):
  This method is inherently unsafe. Stopping a thread with Thread.stop
  causes it to unlock all of the monitors that it has locked (as a
  natural consequence of the unchecked ThreadDeath exception propagating
  up the stack). If any of the objects previously protected by these
  monitors were in an inconsistent state, the damaged objects become
  visible to other threads, potentially resulting in arbitrary behavior.
  Many uses of stop should be replaced by code that simply modifies some
  variable to indicate that the target thread should stop running. The
  target thread should check this variable regularly, and return from its
  run method in an orderly fashion if the variable indicates that it is
  to stop running. If the target thread waits for long periods (on a
  condition variable, for example), the interrupt method should be used
  to interrupt the wait. For more information, see...
- Dario

   to stop running.
Il thread destinatario *della richesta di stop} dovrebbe controllare questa
variaibile e e uscire dal suo
metodo run in un modo migliore (?) se la varabile indica che si deve
fermare...
Quindi ..
il mio semplice stop() va semplicemente omesso, ma cosa vuol dire uscire ...
in a orderly fashion ... dal metodo run ???
era proprio questo che non capivo...
A parte il problema sicurezza, se io uso comunque stop() non si generaro
guai, vero ?
Mirko
che ringrazia per l-aiuto

guai, vero ?
Non è detto che il tuo metodo run() condivida risorse con altri
oggetti. In questo caso puoi usare stop() abbastanza tranquillamente;
certo è che abituarsi a programmare  in maniera inerentemente sicura è
meglio...
-- 
Art. 11: L'italia ripudia la guerra come strumento di offesa
alla libertà degli altri popoli e come mezzo di risoluzione 
delle controversie internazionali. 

 era proprio questo che non capivo...
Esempio copiato da :
http://developer.java.sun.com/developer/onlineTraining/new2java/supplements/
2003/Feb03.html
Spero che ti sia più chiaro :)
Ciao Giuseppe
-- Code --
public class ExampleThreads extends Applet implements Runnable
  {
     String text = "An example of text scrolling in its own thread.";
     TextField field;
     Thread thread;
     boolean running;
     public void init()
       { //open init
        Font fnt = new Font("Monospaced", Font.BOLD, 26);
        setFont(fnt);
        FontMetrics fm = getFontMetrics(fnt);
        int spaceWidth = fm.charWidth(' ');
        int panelWidth = getSize().width;
        int numSpaces = panelWidth / spaceWidth + 1;
        //Add spaces around the text as needed
        for (int i = 0; i < numSpaces; ++i)
          { text = text + ' '; }
        field = new TextField("Type Here");
        add(field);
       } //close init
     public void start()
      {
        if (thread == null)
         {
           thread = new Thread(this);
           running = true;
           thread.start();
         }
      }
     public void run()
      {
        while (running)
         {
           text = text.substring(1, text.length())
                        +text.charAt(0);
           repaint();
           try
             {
               Thread.sleep(100);
              }
              catch (InterruptedException e)
               {}
              }
             }
      public void stop()
       {
         if (thread != null)
          {
            running = false;
            thread = null;
           }
        }
      public void paint(Graphics g)
       {
         g.drawString(text, 0, 150);
       }
 }
-- End Code --

 se io uso comunque stop() non si generaro guai, vero ?
Si generano, si generano...
E' proprio quello succede.
Non usare stop.
Nel thtread A che vuoi fermare ogni tanto controlla il valore
di una variabile che hai inizializzato a zero.
Quando la trovi diversa da zero esci!
Nell'altro thread B (quello che vuole fermare A) semplicemente
setta a un valore diverso da zero la variabile di cui sopra.
La variabile di cui sopra:
  - puo' essere una variabile di classe dichiarata volatile, oppure
  - puo' essere una variabile di istanza: in questo ultimo caso:
     - deve essere dichiarata volatile, oppure
     - deve essere acceduta (sia dal thread A che dal thread B)
       dentro un appropriato synchronized.
- Dario

 ha scritto nel messaggio
news:b4hvqp$20jp5d$1...@ID-59560.news.dfncis.de...


            }
Ora mi è chiaro il concetto della variabile... praticamente è un booleano
che dice a run() se essere o meno eseguito.
è di fatto uno stop implicito. Thanx