Je reçois une exception lors de l'utilisation de Thread.sleep (x) ou wait ()

J'ai essayé de retarder - ou de mettre en veille - mon programme Java, mais une erreur se produit.

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

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

Y a-t-il une étape requise avant d'utiliser les méthodes Thread.sleep()ou wait()?

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

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

Comme d'autres utilisateurs l'ont dit, vous devez entourer votre appel d'un try{...} catch{...}bloc. Mais depuis la sortie de Java 1.5, 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 l'opération de sommeil.

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
}

Il a également des méthodes supplémentaires: TimeUnit Oracle Documentation

Jetez un oeil à cet excellent bref article sur la façon de le faire correctement.

Essentiellement: attrapez le InterruptedException. N'oubliez pas que vous devez ajouter ce bloc catch. La publication explique cela un peu plus loin.

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

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

Mettez votre Thread.sleepbloc de capture d'essai

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

Lors de l'utilisation d' Android (la seule fois où j'utilise Java), je recommanderais d'utiliser un gestionnaire au lieu de mettre le fil 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

Essaye ça:

try{

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

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   
    }
}

C'est pour le délai séquentiel mais pour les délais de boucle, référez-vous à Java Delay / Wait .

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);


  }
}

Une manière plus simple d'attendre est d'utiliser System.currentTimeMillis(), qui renvoie le nombre de millisecondes depuis minuit le 1er janvier 1970 UTC. Par exemple, pour 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 des threads et des exceptions. J'espère que cela t'aides!

Utilisation java.util.concurrent.TimeUnit:

TimeUnit.SECONDS.sleep(1);

Dormez une seconde ou

TimeUnit.MINUTES.sleep(1);

Dormez une minute.

Comme il s'agit d'une boucle, cela présente un problème inhérent - la dérive. Chaque fois que vous exécutez du code, puis que vous dormez, vous vous éloignerez un peu de l'exécution, par exemple, chaque seconde. Si c'est un problème, ne l'utilisez pas sleep.

De plus, sleepn'est pas très flexible en matière de contrôle.

Pour exécuter une tâche toutes les secondes ou avec un retard d'une seconde, je recommande fortement un [ ScheduledExecutorService] [1] et soit [ scheduleAtFixedRate] [2] ou [ scheduleWithFixedDelay] [3].

Pour exécuter la méthode myTasktoutes 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");
}

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. Finalementsleep()Peut vous mordre gravement.

Meilleure pratique pour les applications Java multithread / multicœurs pour utiliser le concept "thread wait". Wait libère tous les verrous et 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 montre 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 la mise en oeuvre:

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();
        }
    }
}

Alternativement, si vous ne souhaitez pas traiter les threads, essayez cette méthode:

public static void pause(int seconds){
    Date start = new Date();
    Date end = new Date();
    while(end.getTime() - start.getTime() < seconds * 1000){
        end = new Date();
    }
}

Il commence lorsque vous l'appelez et se termine lorsque le nombre de secondes s'est écoulé.