Thread.sleep (x) veya wait () kullanırken istisna alıyorum

Java programımı geciktirmeye ya da uyumaya çalıştım, ancak bir hata oluştu.

Thread.sleep(x)Veya kullanamıyorum wait(). Aynı hata mesajı görünür:

bildirilmemiş istisna java.lang.InterruptedException; atılmak veya yakalanmak üzere ilan etmek gerekir.

Thread.sleep()Veya wait()yöntemlerini kullanmadan önce herhangi bir adım gerekiyor mu?

Önünüzde çok fazla okuma var. Derleyici hatalarından istisna işleme, iplik geçirme ve iş parçacığı kesintileri. Ancak bu istediğinizi yapar:

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

Diğer kullanıcıların söylediği gibi, çağrınızı bir try{...} catch{...}blokla çevrelemeniz gerekir . Ancak Java 1.5 yayımlandığından, Thread.sleep (millis) ile aynı olan ancak daha kullanışlı olan TimeUnit sınıfı vardır . Uyku işlemi için zaman birimi seçebilirsiniz.

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
}

Ayrıca ek yöntemleri de vardır: TimeUnit Oracle Belgeleri

Bunu nasıl doğru bir şekilde yapacağınızla ilgili bu mükemmel kısa mesaja bir göz atın .

Temelde: yakalamak InterruptedException. Bu catch bloğunu eklemeniz gerektiğini unutmayın. Mesaj bunu biraz daha açıklıyor.

İstisnaları işlemek için aşağıdaki kodlama yapısını kullanın

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

Thread.sleepDenemek yakalamak blok koymak

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

Android kullanırken (Java kullandığım tek zaman) iş parçacığını uykuya koymak yerine bir işleyici kullanmanızı tavsiye ederim.

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

Referans: http://developer.android.com/reference/android/os/Handler.html

Bunu dene:

try{

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

Bir Java programına gecikme ekleme yollarım.

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

Bu sıralı gecikme içindir, ancak Döngü gecikmeleri için Java Gecikmesi / Beklemesine bakın .

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
}

Örneğin:-

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


  }
}

Beklemenin daha basit bir yolu System.currentTimeMillis(), 1 Ocak 1970 UTC'de gece yarısından bu yana geçen milisaniye sayısını döndürmektir. Örneğin, 5 saniye beklemek için:

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

Bu şekilde, iş parçacıkları ve istisnalarla uğraşmak zorunda kalmazsınız. Bu yardımcı olur umarım!

Kullanım java.util.concurrent.TimeUnit:

TimeUnit.SECONDS.sleep(1);

Bir saniye uyu veya

TimeUnit.MINUTES.sleep(1);

Bir dakika uyu.

Bu bir döngü olduğu için, doğasında var olan bir sorun - sürüklenme ortaya çıkar. Her kod çalıştırdığınızda ve sonra uyuduğunuzda, her saniye biraz koşmaktan sürükleneceksiniz. Bu bir sorunsa kullanmayın sleep.

Ayrıca, sleepkontrol söz konusu olduğunda çok esnek değildir.

Bir görevi her saniye veya bir saniyelik bir gecikmeyle yürütmek için bir [ ] [1] ve [ ] [2] veya [ ] [3] değerlerini şiddetle öneririm .ScheduledExecutorServicescheduleAtFixedRatescheduleWithFixedDelay

Yöntemi myTaskher saniye çalıştırmak için (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() yeni başlayanlar için basittir ve birim testleri ve kavram kanıtları için uygun olabilir.

Ama lütfen YAPMAYIN kullanmak sleep()üretim kodu için. Sonunda sleep()seni kötü ısırır.

Çok iş parçacıklı / çok çekirdekli java uygulamaları için "thread wait" kavramını kullanmak için en iyi uygulama. Bekle, iş parçacığının tuttuğu tüm kilitleri ve monitörleri serbest bırakır, bu da diğer iş parçacıklarının bu monitörleri almasını ve iş parçacığınız huzur içinde uyurken ilerlemesini sağlar.

Aşağıdaki kod bu tekniği göstermektedir:

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 uygulama:

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

Alternatif olarak, iş parçacıklarıyla uğraşmak istemiyorsanız, bu yöntemi deneyin:

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

Aradığınızda başlar ve saniye sayısı geçtiğinde sona erer.