Ola Pessoal,
Gostaria de saber como eu posso fazer um método que seja executado por exemplo, de 10 em 10 minutos? A única solução é utilizar threads, ou existe uma outra???
Obrigado…
[]s
Wagner
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]
[quote=“viecili”]A única solução eh thread sim
while (true) {
metodo();
Thread.sleep(10*60*1000);
}[/quote]
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
[quote=“microfilo”][quote=“viecili”]A única solução eh thread sim
while (true) {
metodo();
Thread.sleep(10*60*1000);
}[/quote]
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();
[/quote]
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…
[quote=“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???[/quote]
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!)
Classe Monitor
[code]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;
}
}[/code]
Classe Processo
[code]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);
}
}[/code]
Classe Main
[code]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();
}
}[/code]
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!! 
Qualquer coisa pode perguntar…
[quote=“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…[/quote]
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: