Parar uma Thread no meio de sua execução e depois começar ela do zero

Programação Java
#1

Gente, estou fazendo uma thread no meu programa, que fica atualizando uma jTable.
Eu ativo ela, clicando no JToggleButton. Mantendo ela ativa.
Quando clico novamente, ela deveria parar.E se eu clicasse novamente, ela deveria começar do zero.

Quando eu ativo ela pela primeira vez, ela funciona.
Mas quando mando parar e executar de novo, gera diversos Erros…

O que devo fazer?

Classe View :

 private boolean activeUpdate = true;
....
  private void jToggleButton_KeepUpdatingActionPerformed(java.awt.event.ActionEvent evt) {
       
        
        if(activeUpdate == false)
        {
          cc.stopTableUpdate();
          activeUpdate = true;
        } else if(activeUpdate == true)
            {
                cc.keepTableUpdated();
                 activeUpdate = false;
            }
        
        
        
        
        
    }

Classe que Controla a parada e a execução :
//Classe CentralControle


    public void keepTableUpdated()
    {
        System.out.println("Method to start Thread commencing...");
       
        if (keepTable.isInterrupted())
        {
            
        } else {
        keepTable.start();
    }
    }
    
    public void stopTableUpdate()
    {
        //keepTable.setStop(false);
        keepTable.interrupt();
    }

Classe da Thread :


package KeepAliveAndUpdated;

import Controle.CentralControle;
import java.util.logging.Level;
import java.util.logging.Logger;

public class KeepTable extends Thread{
    public CentralControle cc;
    private boolean stop = false;
 
    public KeepTable(CentralControle c)
    {
        cc = c;
    }
    
    @Override
    public void run()
    {
   
     while(stop ==false )
     {
        
            try {
                this.sleep(5000); // 5 segundos
                   cc.check();
                  
            } catch (InterruptedException ex) {
                System.out.println("Thread Error - Please Contact Developer");
                stop = true;
            }
     
     }
     
    }

    public boolean isStop() {
        return stop;
    }

    public void setStop(boolean stop) {
        this.stop = stop;
    }
    
    
    

}
#2

vc pode colocar a thread pra dormir, qndo quiser q ela volte basta da um interrupt.

#3

Ué, porque você não chama stop() e cria a thread novamente ?

#4

nao deve ser usado o stop da classe thread (vide javadoc). O correto seria fazer o metodo run terminar.

#5

O stop() esta deprecado e também pode gerar erros.

Vou tentar do jeito que o mauricio me disse…

#6

nao deve ser usado o stop da classe thread (vide javadoc). O correto seria fazer o metodo run terminar.[/quote]

Verdade, tinha me esquecido que stop() é deprecated. Que seja o método interrupt() então. Mas como eu disse, depois ele precisa criar uma nova Thread.

#7

nao deve ser usado o stop da classe thread (vide javadoc). O correto seria fazer o metodo run terminar.[/quote]

Verdade, tinha me esquecido que stop() é deprecated. Que seja o método interrupt() então. Mas como eu disse, depois ele precisa criar uma nova Thread.[/quote]

rá´´aáá

funcionou usando interrupt.
Porém ele da esse erro:

“sleep interrupted”

e Outra coisa, essas threads interrupteds, irão ficar consumindio processamento memória?

#8

nao deve ser usado o stop da classe thread (vide javadoc). O correto seria fazer o metodo run terminar.[/quote]

Verdade, tinha me esquecido que stop() é deprecated. Que seja o método interrupt() então. Mas como eu disse, depois ele precisa criar uma nova Thread.[/quote]

rá´´aáá

funcionou usando interrupt.
Porém ele da esse erro:

“sleep interrupted”

e Outra coisa, essas threads interrupteds, irão ficar consumindio processamento memória?

[/quote]

Processamento não, memória sim. Mas como eu disse, ao reiniciar o processamento você deverá criar uma nova Thread. Se você não manter a referência para a Thread antiga então ela será coletada pelo GC.

#9

[quote]
Processamento não, memória sim. Mas como eu disse, ao reiniciar o processamento você deverá criar uma nova Thread. Se você não manter a referência para a Thread antiga então ela será coletada pelo GC.[/quote]

[code]
public KeepTable keepTable = new KeepTable(this);
…

public void keepTableUpdated()
{
System.out.println(“Method to start Thread commencing…”);

    keepTable = new KeepTable(this);
    keepTable.start();

}[/code]

Desse Jeito ele esta mantendo a referencia ?

#10

[quote=Andre Lopes][quote]
Processamento não, memória sim. Mas como eu disse, ao reiniciar o processamento você deverá criar uma nova Thread. Se você não manter a referência para a Thread antiga então ela será coletada pelo GC.[/quote]

[code]
public KeepTable keepTable = new KeepTable(this);
…

public void keepTableUpdated()
{
System.out.println(“Method to start Thread commencing…”);

    keepTable = new KeepTable(this);
    keepTable.start();

}[/code]

Desse Jeito ele esta mantendo a referencia ? [/quote]

Sem olhar o código todo não dá pra saber. Se você cria a Thread em uma variável pública, existem grandes chances de você não deixar ela ser levada pelo GC, pois você não sabe como a instância será usada.

#11

Então , na verdade essas são as únicas partes em que a thread é referenciada. No resto do código e nas outras classes, nao tem nada dessa thread.

#12

[quote=Andre Lopes]Então , na verdade essas são as únicas partes em que a thread é referenciada. No resto do código e nas outras classes, nao tem nada dessa thread.
[/quote]

Faça-a private então, só para garantir. E eu ainda faria diferente, faria KeepTable implementar Runnable ao invés de estender Thread, e faria o lançamento da trhead assim:

private  KeepTable keepTable = new KeepTable(this);     
...  
  
public void keepTableUpdated()  
    {  
        System.out.println("Method to start Thread commencing..."); 

        Thread t1 = new Thread(keepTable); 

        t1.start();        
    }
#13