Este requisito surgiu no meu aplicativo Android, mas se aplica ao Java em geral. Meu aplicativo "faz alguma coisa" a cada poucos segundos. Eu implementei isso da seguinte maneira (apenas trechos relevantes - não um código completo):

Snippet1:

public class PeriodicTask {

    private boolean running = true;
    private int interval = 5;

    public void startTask(){
        while (running){
            doSomething();
            try{
                Thread.sleep(interval * 1000);
            } catch(InterruptedException e){
                //Handle the exception.
            }
        }
    }

    public void stopTask(){
        this.running = false;
    }

    public void setInterval(int newInterval){
        this.interval = newInterval;
    }
}

O problema dessa abordagem, como você pode ver, é que setInterval () não é imediatamente eficaz. Só entra em vigor após a conclusão de um sono anterior ().

Como meu caso de uso permite que o usuário final defina o intervalo em etapas fixas (de 1 segundo - de 1 a 60 segundos), modifiquei a implementação para dormir dentro de um loop; e verifique o novo valor do intervalo a cada segundo, da seguinte maneira:

Snippet2:

public class PeriodicTask {

    private boolean running = true;
    private int interval = 5;
    private int loopCounter = 0;

    public void startTask(){
        while (running){
            doSomething();
            try{
                while(loopCounter < interval) {
                    Thread.sleep(1 * 1000);
                    loopCounter ++;
                }
            } catch(InterruptedException e){
                //Handle the exception.
            }
        }
    }

    public void stopTask(){
        this.running = false;
    }

    public void setInterval(int newInterval){
        synchronized (this) {
            this.interval = newInterval;
            if(newInterval < loopCounter){
                loopCounter = 0;
            }
        }
    }
}

Existe um motivo para não usar essa abordagem?

Vi recentemente ointerrupt() método para esse fim. Mas não consegui descobrir exatamente como usá-lo. Por um lado, o método de interrupção, diferente do método de suspensão, não éstatic. E daíThread interrompo?

public void setInterval(int newInterval){
        this.interval = newInterval;
        //What thread do I call interrupt() on?
    }

Em segundo lugar, se eu conseguir interromper o sonoThread, Acredito que ocatchloco @ para oInterruptedException será executado. No entanto, precisarei chamar ostartTask() novamente neste momento. Estou confuso quanto ao término desta recursão. Eu passei por várias perguntas sobre SO com relação ao uso de interrupt (), mas não consegui descobrir nada que me ajudass

Algumas dicas?

EDIT- Mais detalhes sobre os requisitos exatos:

aplicativo @MY busca alguns valores usando uma chamada REST a cada poucos segundos. O intervalo de atualização é configurável pelo usuári

Agora, digamos que o intervalo de atualização tenha sido definido para 60 segundos. O snippet1 que eu publiquei funcionaria (incorretamente) da seguinte maneira:

O fio entra em suspensão por 60 segundogora, digamos que o usuário altere o intervalo de atualização para 5 segundos. A linha ainda está dormindo.OPeriodicTask veria o novo intervalo de atualização somente após os 60 segundos expirare

O requisito exato é que os novos intervalos de atualização sejam efetivados imediatamente (ou pelo menos um segundo após a definição - pois é isso que o usuário provavelmente perceberá de qualquer maneira

Meu Snippet2 e Snippet3 são tentativas para atingir esse requisit