Saya mendapatkan pengecualian saat menggunakan Thread.sleep (x) atau wait ()

Saya telah mencoba untuk menunda - atau menidurkan - program Java saya, tetapi kesalahan terjadi.

Saya tidak dapat menggunakan Thread.sleep(x)atau wait(). Pesan kesalahan yang sama muncul:

java.lang.InterruptedException yang tidak dilaporkan tidak dilaporkan; harus ditangkap atau dinyatakan dibuang.

Apakah ada langkah yang diperlukan sebelum menggunakan metode Thread.sleep()atau wait()?

Anda memiliki banyak bacaan di depan Anda. Dari kesalahan kompiler melalui penanganan eksepsi, interupsi threading dan thread. Tetapi ini akan melakukan apa yang Anda inginkan:

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

Seperti yang dikatakan pengguna lain, Anda harus mengelilingi panggilan Anda dengan sebuah try{...} catch{...}blok. Tetapi sejak Java 1.5 dirilis, ada kelas TimeUnit yang melakukan hal yang sama dengan Thread.sleep (millis) tetapi lebih nyaman. Anda dapat memilih unit waktu untuk operasi tidur.

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
}

Juga memiliki metode tambahan: TimeUnit Oracle Documentation

Lihat tulisan singkat yang luar biasa ini tentang cara melakukan ini dengan benar.

Intinya: tangkap InterruptedException. Ingatlah bahwa Anda harus menambahkan catch-block ini. Pos menjelaskan ini sedikit lebih jauh.

Gunakan konstruksi kode berikut untuk menangani pengecualian

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

Masukkan Thread.sleepblok percobaan Anda

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

Saat menggunakan Android (satu-satunya saat ketika saya menggunakan Java) Saya akan merekomendasikan menggunakan handler daripada meletakkan utas tidur.

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

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

Coba ini:

try{

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

Cara saya menambahkan penundaan ke program 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   
    }
}

Ini untuk penundaan berurutan tetapi untuk penundaan Loop, lihat 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
}

misalnya:-

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


  }
}

Cara yang lebih sederhana untuk menunggu adalah menggunakan System.currentTimeMillis(), yang mengembalikan jumlah milidetik sejak tengah malam pada 1 Januari 1970 UTC. Misalnya, menunggu 5 detik:

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

Dengan cara ini, Anda tidak perlu repot dengan utas dan pengecualian. Semoga ini membantu!

Gunakan java.util.concurrent.TimeUnit:

TimeUnit.SECONDS.sleep(1);

Tidur selama satu detik atau

TimeUnit.MINUTES.sleep(1);

Tidur sebentar.

Karena ini adalah loop, ini menyajikan masalah bawaan - drift. Setiap kali Anda menjalankan kode dan kemudian tidur, Anda akan terhanyut sedikit dari berlari, katakanlah, setiap detik. Jika ini masalah maka jangan gunakan sleep.

Lebih jauh, sleeptidak terlalu fleksibel dalam hal kontrol.

Untuk menjalankan tugas setiap detik atau pada penundaan satu detik saya sangat merekomendasikan [ ScheduledExecutorService] [1] dan [ scheduleAtFixedRate] [2] atau [ scheduleWithFixedDelay] [3].

Untuk menjalankan metode myTasksetiap detik (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() sederhana untuk pemula dan mungkin sesuai untuk unit test dan bukti konsep.

Tapi tolong JANGAN gunakan sleep()untuk kode produksi. Akhirnyasleep() mungkin akan sangat menggigit Anda.

Praktik terbaik untuk aplikasi java multithreaded / multicore untuk menggunakan konsep "thread wait". Tunggu, lepaskan semua kunci dan monitor yang dipegang oleh utas, yang memungkinkan utas lain memperoleh monitor itu dan melanjutkan sementara utas Anda tidur dengan damai.

Kode di bawah ini menunjukkan teknik itu:

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

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

Atau, jika Anda tidak ingin berurusan dengan utas, coba metode ini:

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

Itu dimulai ketika Anda memanggilnya, dan berakhir ketika jumlah detik telah berlalu.