Tôi nhận được ngoại lệ khi sử dụng Thread.s ngủ (x) hoặc chờ ()

Tôi đã cố trì hoãn - hoặc đặt chế độ ngủ - chương trình Java của tôi, nhưng đã xảy ra lỗi.

Tôi không thể sử dụng Thread.sleep(x)hoặc wait(). Thông báo lỗi tương tự xuất hiện:

ngoại lệ không được báo cáo java.lang.InterruptedException; phải bị bắt hoặc tuyên bố sẽ bị ném

Có bất kỳ bước cần thiết trước khi sử dụng Thread.sleep()hoặc wait()phương pháp?

Bạn có rất nhiều đọc trước bạn. Từ lỗi trình biên dịch thông qua xử lý ngoại lệ, luồng và gián đoạn luồng. Nhưng điều này sẽ làm những gì bạn muốn:

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

Như những người dùng khác đã nói rằng bạn nên bao quanh cuộc gọi của mình bằng một try{...} catch{...}khối. Nhưng kể từ khi Java 1.5 được phát hành, có lớp TimeUnit hoạt động tương tự như Thread.s ngủ (millis) nhưng thuận tiện hơn. Bạn có thể chọn đơn vị thời gian cho hoạt động ngủ.

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
}

Ngoài ra, nó có các phương thức bổ sung: Tài liệu Oracle TimeUnit

Có một cái nhìn vào bài viết ngắn gọn tuyệt vời này về cách làm điều này đúng.

Chủ yếu: bắt các InterruptedException. Hãy nhớ rằng bạn phải thêm khối bắt này. Bài viết giải thích điều này một chút nữa.

Sử dụng cấu trúc mã hóa sau để xử lý các ngoại lệ

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

Đặt Thread.sleeptrong một khối bắt thử

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

Khi sử dụng Android (lần duy nhất khi tôi sử dụng Java), tôi sẽ khuyên bạn nên sử dụng trình xử lý thay vì đặt luồng vào chế độ ngủ.

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

Tham khảo: http://developer.android.com/reference/android/os/Handler.html

Thử cái này:

try{

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

Các cách của tôi để thêm độ trễ cho chương trình 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   
    }
}

Đây là sự chậm trễ tuần tự nhưng đối với độ trễ Vòng lặp tham khảo Độ trễ / Chờ của Java .

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
}

ví dụ:-

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


  }
}

Một cách đơn giản hơn để chờ đợi là sử dụng System.currentTimeMillis(), trả về số mili giây kể từ nửa đêm ngày 1 tháng 1 năm 1970 UTC. Ví dụ: để chờ 5 giây:

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

Bằng cách này, bạn không phải loay hoay với các chủ đề và ngoại lệ. Hi vọng điêu nay co ich!

Sử dụng java.util.concurrent.TimeUnit:

TimeUnit.SECONDS.sleep(1);

Ngủ một giây hoặc

TimeUnit.MINUTES.sleep(1);

Ngủ một phút.

Vì đây là một vòng lặp, điều này thể hiện một vấn đề cố hữu - trôi dạt. Mỗi khi bạn chạy mã và sau đó ngủ, bạn sẽ trôi đi một chút từ việc chạy, nói, mỗi giây. Nếu đây là một vấn đề thì không nên sử dụngsleep .

Thêm nữa, sleep không linh hoạt khi kiểm soát.

Để chạy một nhiệm vụ mỗi giây hoặc ít một giây chậm trễ tôi sẽ mạnh mẽ đề nghị một [ ScheduledExecutorService] [1] và một trong hai [ scheduleAtFixedRate] [2] hoặc [scheduleWithFixedDelay ] [3].

Để chạy phương thức myTaskmỗi giây (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() là đơn giản cho người mới bắt đầu và có thể thích hợp cho các bài kiểm tra đơn vị và bằng chứng về khái niệm.

Nhưng xin vui lòng KHÔNG sử dụng sleep()cho mã sản xuất. Cuối cùngsleep() có thể cắn bạn rất tệ.

Cách thực hành tốt nhất cho các ứng dụng java đa luồng / đa lõi để sử dụng khái niệm "luồng chờ". Chờ phát hành tất cả các khóa và màn hình được giữ bởi luồng, cho phép các luồng khác có được các màn hình đó và tiến hành trong khi luồng của bạn đang ngủ yên.

Mã dưới đây chứng minh rằng kỹ thuật:

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 thực hiện:

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

Ngoài ra, nếu bạn không muốn xử lý các chủ đề, hãy thử phương pháp này:

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

Nó bắt đầu khi bạn gọi nó và kết thúc khi số giây đã trôi qua.