Executar método de 10 em 10 minutos

A única solução eh thread sim

while (true) { metodo(); Thread.sleep(10*60*1000); }

Ola,

Obrigado pela ajuda!

[]s

Wagner

Depende… não necessariamente vc deve usar só Thread…
Vc pode usar a classe Timer

Ex:

/** Timer de verificação do status. */
private javax.swing.Timer tmrStatus;

// timer de verificação da comuniação

tmrStatus = new Timer(TIMER_VERIFICA_CONEXAO, new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

//método a ser executado

verificaConexao(evt);

}

});

onde TIMER_VERIFICA_CONEXAO é o tempo em ms de acionamento do timer.

// inicio o timer
tmrStatus.start();

/*  Método a ser executado a cada x ms

*/

private void verificaConexao(java.awt.event.ActionEvent evt) {

//coloque aki a sua lógica

}

[/img]

“viecili”:

A única solução eh thread sim

while (true) { metodo(); Thread.sleep(10*60*1000); }

uma solução em uma unica thread não é uma boa solução pois impede o programa de fazer outras coisas

e um conselho, não use thread.sleep qndo se quer parar por uma quantidade exata de tempo. use um while que compara o tempo decorrido

int TIMEOUT = 10 * 60 * 1000; 
/*10 min, tem 60 seg, 1 seg tem 1000 miles.
logo, 10 min tem 600.000 milesimos*/
date d = new Date();
while((new Date().getTime() - d.getTime()) < TIMEOUT)
  metodo();

Ola Pessoal,

Mais uma vez obrigado pelas dicas, mas estou com uma outra dúvida.

Por exemplo, eu executo um processo, e solicito que execute esse método que será executado de 10 em 10 minutos. Esse processo fica executando… vamos chamar de processo1, e um outro processo (processo2) solicita a esse metodo (10 em 10 minutos) que fique executando tb. Como que eu posso tratar esse exemplo de vários processos sendo executados e retornando parâmetros diferentes. Não sei se eu estou certo, mas o uso de threads é justamente para ter vários processos sendo executandos ao mesmo tempo, é isso? E se terminar o processo1 como que eu mando “matar” a execução do método???

[]s

Wagner

“microfilo”:

“viecili”:

A única solução eh thread sim

while (true) { metodo(); Thread.sleep(10*60*1000); }

uma solução em uma unica thread não é uma boa solução pois impede o programa de fazer outras coisas

e um conselho, não use thread.sleep qndo se quer parar por uma quantidade exata de tempo. use um while que compara o tempo decorrido

int TIMEOUT = 10 * 60 * 1000; /*10 min, tem 60 seg, 1 seg tem 1000 miles. logo, 10 min tem 600.000 milesimos*/ date d = new Date(); while((new Date().getTime() - d.getTime()) < TIMEOUT) metodo();

no seu ex vc esqueceu do ; depois do while… desse jeito vai ficar executando o metodo direto por 10 minutos…

e tipo, usando Thread.sleep vc n consome recursos do processador, se vc manter em um loop vc vai deixar o computador MUITO lento…
para resolver o problema do Thread.sleep nao ser preciso, vc pode somar o tempo ao valor antigo…

public void loop(){
 final int TIMEOUT = 600000;
 (new Thread(){
  public void run(){
   int fim =  System.currentTimeMillis();
   while (true){
    fim += TIMEOUT;
    try{
     Thread.sleep(fim - System.currentTimeMillis());
    }
    catch (Exception erro){}
    Classe.metodo(); // assumindo q o metodo eh estatico
   }
  }
 }).start();
}

desse jeito nao vai deixar o pc lento… e como ta sempre acrescentando o TIMEOUT, pode ateh n ser extato algumas vezes, mas dai nao vai ficar “acumulando” a diferenca…

"java_duvidas":

Por exemplo, eu executo um processo, e solicito que execute esse método que será executado de 10 em 10 minutos. Esse processo fica executando.. vamos chamar de processo1, e um outro processo (processo2) solicita a esse metodo (10 em 10 minutos) que fique executando tb. Como que eu posso tratar esse exemplo de vários processos sendo executados e retornando parâmetros diferentes. Não sei se eu estou certo, mas o uso de threads é justamente para ter vários processos sendo executandos ao mesmo tempo, é isso? E se terminar o processo1 como que eu mando "matar" a execução do método?????

Esta sua idéia está muito confusa, vc parece estar confundindo método com processo... só sei q não captei o q vc está querendo.
Mas vou te dar um exemplo bem simples de uso de Threads e monitores (se quiser saber mais sobre monitores e Threads dê uma olhada no Livro do Deitel&Deitel 3ªed - mto bom!)

public class Monitor {
  private boolean parar = false;
  public synchronized int dobrarValor(int valor) {
    valor = valor << 1;
    this.parar = valor > 1000;
    return valor;
  }

  public boolean parar() {
    return parar;
  }
}

public class Processo extends Thread {
  private Monitor monitor;
  private int base;
  public Processo(Monitor monitor, int base) {
    this.monitor = monitor;
    this.base = base;
  }

  void run() {
    while(!monitor.parar())
      base = monitor.dobraValor(base);
      sleep(3000);
    }
    System.out.println("parou! final = "+base);
  }
}

public class Main {
  public static void main(String[] args) {
    Monitor monitor = new Monitor();

    Thread p1 = new Processo(monitor,1);
    Thread p2 = new Processo(monitor,2);
    Thread p3 = new Processo(monitor,10);

    p1.start();
    p2.start();
    p3.start();
  }
}

Veja que é um exemplo puramente didático para mostrar como um método pode ser acessado de modo concorrente por vários processos. Nesta situação existe uma classe Monitor (conceito de monitor) que provê o método dobraValor(), uma instância desta classe é passada para os processos que irão executar o método de 3 em 3 segundos. O acesso ao método é sincronizado, ou seja, dois processos nunca estarão executando o método ao mesmo tempo. Os processos somente param sua execução quando o dobro de um valor (de qualquer processo) superar 1000.

Embora o código seja simples, os conceitos envolvidos requerem um certo entendimento prévio de programação paralela, monitores/semáforos etc... A programação com Threads é bastante poderosa, mas causa uma boa dor de cabeça pra manter a consistência dos dados envolvidos e do acesso aos métodos.

Outra coisa Wagner, por favor, não caia nessa de fazer loop comparando valor do tempo corrente do sistema, seja elegante, não escove os bits... dê a eles um banho de loja!! :wink:

Qualquer coisa pode perguntar...

“Felipe”:

e tipo, usando Thread.sleep vc n consome recursos do processador, se vc manter em um loop vc vai deixar o computador MUITO lento…
para resolver o problema do Thread.sleep nao ser preciso, vc pode somar o tempo ao valor antigo…

public void loop(){
 final int TIMEOUT = 600000;
 (new Thread(){
  public void run(){
   int fim =  System.currentTimeMillis();
   while (true){
    fim += TIMEOUT;
    try{
     Thread.sleep(fim - System.currentTimeMillis());
    }
    catch (Exception erro){}
    Classe.metodo(); // assumindo q o metodo eh estatico
   }
  }
 }).start();
}

desse jeito nao vai deixar o pc lento… e como ta sempre acrescentando o TIMEOUT, pode ateh n ser extato algumas vezes, mas dai nao vai ficar “acumulando” a diferenca…

mesmo assim há probabilidade de imprecisão
se o timeout for pequeno e cada execução deve impreterivelmente ser executada na frequencia determinada, Thread.sleep não é muito recomemdado

eu esqueci mesmo do ;…

mas tipo, eh melhor nao ficar perfeitamente preciso do q deixar o computador extremamente lento…

qquer coisa, eh soh usar um tempo menor e nos ultimos milisegundos ai sim fazer do seu jeito, mas agora ficar frocando direto eh dar uma facada no desempenho…

e o preço que se paga pra ter uma coisa com precisão nanometrica :razz: