Thread.sleep (x) 또는 wait ()를 사용할 때 예외가 발생합니다.

Java 프로그램을 지연 시키거나 절전 모드로 전환하려고했지만 오류가 발생했습니다.

내가 사용할 수 없습니다 해요 Thread.sleep(x)나 wait(). 동일한 오류 메시지가 나타납니다.

보고되지 않은 예외 java.lang.InterruptedException; 던지려면 잡히거나 선언해야합니다.

Thread.sleep()또는 wait()방법을 사용하기 전에 필요한 단계가 있습니까?

당신은 당신보다 앞서 독서를 많이합니다. 컴파일러 오류부터 예외 처리, 스레딩 및 스레드 중단까지. 그러나 이것은 당신이 원하는 것을 할 것입니다 :

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

다른 사용자가 말했듯이 try{...} catch{...}블록으로 통화를 둘러싸 야한다고 말했습니다 . 그러나 Java 1.5가 출시 된 이후 Thread.sleep (millis) 와 동일 하지만 더 편리한 TimeUnit 클래스 가 있습니다. 수면 작동을위한 시간 단위를 선택할 수 있습니다.

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
}

또한 추가 방법이 있습니다 : TimeUnit Oracle Documentation

봐 가지고 이 우수한 간단한 포스트에서 적절하게이 작업을 수행하는 방법에 대한합니다.

본질적으로 :를 잡아라 InterruptedException. 이 catch-block을 추가해야합니다. 포스트는 이것을 조금 더 설명합니다.

다음 코딩 구문을 사용하여 예외를 처리하십시오.

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

Thread.sleep시도 캐치 블록에 넣어

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

사용하는 경우 안드로이드 (I Java를 사용하는 경우에만 시간) 나는 잠에 실을 꿰기 대신 핸들러를 사용하는 것이 좋습니다 것입니다.

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

참조 : http://developer.android.com/reference/android/os/Handler.html

이 시도:

try{

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

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

순차 지연에 대한 것이지만 루프 지연에 대해서는 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
}

예 :-

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


  }
}

기다리는 가장 간단한 방법은을 사용하는 것입니다.이 방법은 System.currentTimeMillis()1970 년 1 월 1 일 자정 이후 UTC (밀리 초)를 반환합니다. 예를 들어 5 초 동안 기다리려면

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

이런 식으로 스레드와 예외에 대해 고민 할 필요가 없습니다. 도움이 되었기를 바랍니다!

사용 java.util.concurrent.TimeUnit:

TimeUnit.SECONDS.sleep(1);

1 초 동안 자거나

TimeUnit.MINUTES.sleep(1);

잠을 잔다.

이것이 루프이기 때문에 이것은 고유 한 문제인 드리프트를 나타냅니다. 코드를 실행 한 다음 잠들 때마다 매 초마다 조금씩 표류하게됩니다. 이것이 문제라면를 사용하지 마십시오 sleep.

또한 sleep제어와 관련하여 매우 유연하지 않습니다.

매초 또는 1 초 지연으로 작업을 실행하려면 [ ] [1]과 [ ] [2] 또는 [ ] [3]을 강력히 권장합니다 .ScheduledExecutorServicescheduleAtFixedRatescheduleWithFixedDelay

myTask매초마다 메소드를 실행하려면 (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() 초보자에게는 간단하며 단위 테스트 및 개념 증명에 적합 할 수 있습니다.

그러나 프로덕션 코드에는 사용 하지 마십시오sleep() . 결국 sleep()당신을 심하게 물릴 수 있습니다.

"스레드 대기"개념을 사용하기위한 멀티 스레드 / 멀티 코어 Java 애플리케이션에 대한 모범 사례. Wait는 스레드가 보유한 모든 잠금 및 모니터를 해제하여 다른 스레드가 해당 모니터를 획득하고 스레드가 평화롭게 잠자는 동안 진행할 수 있도록합니다.

아래 코드는 해당 기술을 보여줍니다.

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 이행:

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

또는 스레드를 처리하지 않으려면 다음 방법을 시도하십시오.

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

호출 할 때 시작하고 초가 지나면 종료됩니다.