web-dev-qa-db-fra.com

Je reçois une exception lorsque j'utilise Thread.sleep (x) ou wait ()

J'ai essayé de retarder ou de mettre en veille mon programme Java, mais une erreur s'est produite.

Je ne parviens pas à utiliser Thread.sleep(x) ni wait(). Le même message d'erreur apparaît:

exception non signalée Java.lang.InterruptedException; doit être attrapé ou déclaré comme jeté.

Une étape est-elle nécessaire avant d’utiliser les méthodes Thread.sleep() ou wait()?

javasleep
340
vincent low

Vous avez beaucoup de lecture devant vous. Des erreurs du compilateur à la gestion des exceptions, aux threads et aux interruptions de threads. Mais cela fera ce que vous voulez:

try {
    Thread.sleep(1000);                 //1000 milliseconds is one second.
} catch(InterruptedException ex) {
    Thread.currentThread().interrupt();
}
574
Konrad Garus

Comme d'autres utilisateurs l'ont dit, vous devez entourer votre appel d'un bloc try{...} catch{...}. Mais depuis que Java 1.5 a été publié, il existe une classe TimeUnit qui fait la même chose que Thread.sleep (millis) mais est plus pratique . Vous pouvez choisir l’unité de temps pour le mode veille.

try {
    TimeUnit.NANOSECONDS.sleep(100);
    TimeUnit.MICROSECONDS.sleep(100);
    TimeUnit.MILLISECONDS.sleep(100);
    TimeUnit.SECONDS.sleep(100);
    TimeUnit.MINUTES.sleep(100);
    TimeUnit.HOURS.sleep(100);
    TimeUnit.DAYS.sleep(100);
} catch (InterruptedException e) {
    //Handle exception
}

En outre, il dispose de méthodes supplémentaires: Documentation TimeUnit Oracle

195
Alexander Ivanov

Jetez un coup d'œil à cet excellent article bref pour savoir comment le faire correctement.

Essentiellement: attrapez le InterruptedException . Rappelez-vous que vous devez ajouter ce blocage. Le post explique cela un peu plus loin.

29
Abel

Utilisez la structure de codage suivante pour gérer les exceptions

try {
  Thread.sleep(1000);
} catch (InterruptedException ie) {
    //Handle exception
}
13
Jatin

Mettez votre Thread.sleep dans un bloc catch try

try {
    //thread to sleep for the specified number of milliseconds
    Thread.sleep(100);
} catch ( Java.lang.InterruptedException ie) {
    System.out.println(ie);
}
8
JoseK

Lorsque vous utilisez Android (la seule fois où j'utilise Java), je vous recommande d'utiliser un gestionnaire au lieu de mettre le thread en veille.

final Handler handler = new Handler();
    handler.postDelayed(new Runnable() {
        @Override
        public void run() {
            Log.i(TAG, "I've waited for two hole seconds to show this!");

        }
    }, 2000);

Référence: http://developer.Android.com/reference/Android/os/Handler.html

7
Sindri Þór

Mes façons d’ajouter du retard à un programme Java.

public void pause1(long sleeptime) {
    try {
        Thread.sleep(sleeptime);
    } catch (InterruptedException ex) {
        //ToCatchOrNot
    }
}

public void pause2(long sleeptime) {
    Object obj = new Object();
    if (sleeptime > 0) {
        synchronized (obj) {
            try {
                obj.wait(sleeptime);
            } catch (InterruptedException ex) {
                //ToCatchOrNot
            }
        }
    }
}
public void pause3(long sleeptime) {
    expectedtime = System.currentTimeMillis() + sleeptime;
    while (System.currentTimeMillis() < expectedtime) {
        //Empty Loop   
    }
}

Ceci concerne les délais séquentiels, mais pour les délais de boucle, reportez-vous à Java Delay/Wait .

3
D.R.Bendanillo
public static void main(String[] args) throws InterruptedException {
  //type code


  short z=1000;
  Thread.sleep(z);/*will provide 1 second delay. alter data type of z or value of z for longer delays required */

  //type code
}

par exemple:-

class TypeCasting {

  public static void main(String[] args) throws InterruptedException {
    short f = 1;
    int a = 123687889;
    short b = 2;
    long c = 4567;
    long d=45;
    short z=1000;
    System.out.println("Value of a,b and c are\n" + a + "\n" + b + "\n" + c + "respectively");
    c = a;
    b = (short) c;
    System.out.println("Typecasting...........");
    Thread.sleep(z);
    System.out.println("Value of B after Typecasting" + b);
    System.out.println("Value of A is" + a);


  }
}
3
user3798741

Essaye ça:

try{

    Thread.sleep(100);
}catch(Exception e)
{
   System.out.println("Exception caught");
}
3
SlickJava

Utilisez Java.util.concurrent.TimeUnit:

TimeUnit.SECONDS.sleep(1);

Dormez une seconde ou

TimeUnit.MINUTES.sleep(1);

Dors une minute.

Comme il s’agit d’une boucle, cela pose un problème inhérent - la dérive. Chaque fois que vous exécutez du code, puis que vous dormez, vous vous écartez un peu, par exemple, chaque seconde. S'il s'agit d'un problème, n'utilisez pas sleep.

De plus, sleep n'est pas très flexible en termes de contrôle.

Pour exécuter une tâche toutes les secondes ou toutes les secondes, je voudrais fortement recommander un [ScheduledExecutorService] [1] et soit [scheduleAtFixedRate] [2] ou [scheduleWithFixedDelay] [3].

Pour exécuter la méthode myTask toutes les secondes (Java 8):

public static void main(String[] args) {
    final ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
    executorService.scheduleAtFixedRate(App::myTask, 0, 1, TimeUnit.SECONDS);
}

private static void myTask() {
    System.out.println("Running");
}
0
Gavriel Cohen

Thread.sleep() est simple pour les débutants et peut convenir aux tests unitaires et aux preuves de concept.

Mais s'il vous plaît NE PAS utiliser sleep() pour le code de production. Finalement, sleep() risque de vous mordre mal.

Il est recommandé aux applications Java multithreads/multicœurs d'utiliser le concept "attente de thread". Wait libère tous les verrous et les moniteurs détenus par le thread, ce qui permet aux autres threads d'acquérir ces moniteurs et de continuer pendant que votre thread dort paisiblement.

Le code ci-dessous illustre cette technique:

import Java.util.concurrent.TimeUnit;
public class DelaySample {
    public static void main(String[] args) {
       DelayUtil d = new DelayUtil();
       System.out.println("started:"+ new Date());
       d.delay(500);
       System.out.println("half second after:"+ new Date());
       d.delay(1, TimeUnit.MINUTES); 
       System.out.println("1 minute after:"+ new Date());
    }
}

DelayUtil implémentation:

import Java.util.concurrent.TimeUnit;
import Java.util.concurrent.locks.Condition;
import Java.util.concurrent.locks.ReentrantLock;

public class DelayUtil {
    /** 
    *  Delays the current thread execution. 
    *  The thread loses ownership of any monitors. 
    *  Quits immediately if the thread is interrupted
    *  
    * @param durationInMillis the time duration in milliseconds
    */
   public void delay(final long durationInMillis) {
      delay(durationInMillis, TimeUnit.MILLISECONDS);
   }

   /** 
    * @param duration the time duration in the given {@code sourceUnit}
    * @param unit
    */
    public void delay(final long duration, final TimeUnit unit) {
        long currentTime = System.currentTimeMillis();
        long deadline = currentTime+unit.toMillis(duration);
        ReentrantLock lock = new ReentrantLock();
        Condition waitCondition = lock.newCondition();

        while ((deadline-currentTime)>0) {
            try {
                lock.lockInterruptibly();    
                waitCondition.await(deadline-currentTime, TimeUnit.MILLISECONDS);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            } finally {
                lock.unlock();
            }
            currentTime = System.currentTimeMillis();
        }
    }
}
0
Valchkou

Un moyen plus simple d’attendre consiste à utiliser System.currentTimeMillis(), qui renvoie le nombre de millisecondes écoulées depuis le 1er janvier 1970 à minuit UTC. Par exemple, attendre 5 secondes:

public static void main(String[] args) {
    //some code
    long original = System.currentTimeMillis();
    while (true) {
        if (System.currentTimeMillis - original >= 5000) {
            break;
        }
    }
    //more code after waiting
}

De cette façon, vous n'avez pas à vous occuper de threads et d'exceptions. J'espère que cela t'aides!

0
Sam