Melhores práticas com threads

Bom dia pessoal. Gostaria de uma sugestão a respeito de melhores práticas de desenvolvimento para Threads.
Por exemplo, seria plausível criar um modelo de thread “padrão” para timer? uma superclasse onde eu pudesse aproveitar para execução de comandos de tempos em tempos, ou uma só vez após determinado tempo?

e se caso for plausível, como eu poderia de forma “correta” fazer a chamada desse metodo que será executado de tempos em tempos? um metodo “executar()” da classe “Timer” para ser reescrito numa subclasse ou na hora da instânciação?

algo como:

public class Timer extends Thread
{
  private int tempo;
  public Timer(){}
  public Timer(int t){...}

  public setTempo(int i){...}

  //metodo que executa qualquer coisa na chamada do timer
  public void executar(){}

  public void run()
  {
    try
    {
      Thread.sleep(tempo);
    }
    catch(InterruptedException e){...}
    executar();
  }  
}

enfim, estou mais preocupado em entenderem minha pergunta do que respondê-la, pois não sei se falei grego ou fiz confusão.
Grato a todos e um abraço!

Olá chambs

Bom, eu não entendo muito de java ou threads, mas é exatamente isso que eu estou fazendo no meu projeto: criando uma classe timer para atualizar minhas animações num tilemap...

Para o caso de você quiser matar a thread logo após a primeira execução, é só fazer igual ao que você fez (na verdade não sei pra que esse Thread.slep() aí, já que ele não está em loop).

Minha classe é assim:

/*
 * Created on 05/10/2003
 *
 * To change the template for this generated file go to
 * Window - Preferences - Java - Code Generation - Code and Comments
 */

/**
 * @author Eduardo Machado de Oliveira
 *
 * <p>Classe que implementa um timer para atualizar a visualização do mapa.</p>
 */
public class TimerMapa implements Runnable{
	private long timer, espera;
	private boolean continuar;
	private Thread thread;
	
	/** <p>Cria um novo objeto TimerMapa e começa a contar.</p>
	 * 
	 * @param espera Intervalo de espera entre cada incremento, em mili segundos.
	 */
	public TimerMapa(long espera) {
		this.timer = 0;
		this.espera = espera;
		this.thread = null;
		iniciar();
	}
	
	/** <p>Inicia ou reinicia a contagem de tempo.</p>
	 * 
	 */
	public void iniciar() {
		this.continuar = true;
		if (this.thread == null) {
			this.thread = new Thread(this);
		}
		if (this.thread != null) {
			this.thread.start();
		}
	}
	
	/** <p>Para a contagem de tempo.</p>
	 * 
	 */
	public void parar() {
		if (this.thread != null) {
			this.thread = null;
		} 
		continuar = false;
	}

	/** <p>Lê o valor de espera, em mili segundos, entre cada intervalo.</p>
	 * 
	 * @return Intervalo de tempo de espera, em mili segundos.
	 */
	public long getEspera() {
		return espera;
	}

	/** <p>Altera o tempo de espera, em mili segundos, entre cada intervalo.</p>
	 * 
	 * @param espera Novo intervalo de tempo de espera, em mili segundos.
	 */
	public void setEspera(long espera) {
		this.espera = espera;
	}

	/** <p>Lê a quantidade de tempo que passou.</p>
	 * 
	 * @return O valor do timer.
	 */
	public long getTimer() {
		return timer;
	}

	/** <p>Altera a quantidade de tempo que passou.</p>
	 * 
	 * @param timer O novo valor do timer.
	 */
	public void setTimer(long timer) {
		this.timer = timer;
	}
	
	/** <p>Decrementa o timer em uma unidade.</p>
	 * 
	 */
	public void decTimer() {
		this.timer--;
	}

	/* (non-Javadoc)
	 * @see java.lang.Runnable#run()
	 */
	public void run() {
		while (continuar) {
			timer++;
			try {
				Thread.sleep(espera);
			}
			catch (Exception e) {
				System.out.println(e.getMessage());
			}
		}
	}

}

Caso você queira mudar ara rodar um certo número de vezes, o jeito seria trocar de boolean para int o atributo continuar e passar no construtor o valor dele, e no loop decrementá-lo. Lembre-se de associar um valor especial para ele para indicar que ele não deve ser decrementado caso esteja com esse valor (tipo Integer.MAX_INT, acho que é isso).

Falou!

^__^

1 Resposta

Topicos relacionados