안드로이드에서 스레드 또는 프로세스를 일시 중지 / 수면하는 방법은 무엇입니까?

두 줄의 코드 사이에 일시 중지하고 싶습니다.

-> 사용자가 버튼 (사실 카드)을 클릭 하고이 버튼의 배경을 변경하여 표시합니다.

thisbutton.setBackgroundResource(R.drawable.icon);

-> 1 초 후에 배경을 다시 변경하여 버튼의 이전 상태로 돌아 가야합니다.

thisbutton.setBackgroundResource(R.drawable.defaultcard);

->이 두 줄의 코드 사이에서 스레드를 일시 중지하려고했습니다.

try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}

그러나 이것은 작동하지 않습니다. 어쩌면 일시 중지 해야하는 스레드가 아닌 프로세스일까요?

또한 시도했지만 작동하지 않습니다.

new Reminder(5);

이것으로 :

public class Reminder {

Timer timer;

        public Reminder(int seconds) {
            timer = new Timer();
            timer.schedule(new RemindTask(), seconds*1000);
        }

        class RemindTask extends TimerTask {
            public void run() {
                System.out.format("Time's up!%n");
                timer.cancel(); //Terminate the timer thread
            }
        }  
    }

스레드 또는 프로세스를 일시 중지 / 취침하려면 어떻게해야합니까?

이 문제에 대한 한 가지 해결책은 Handler.postDelayed () 메소드 를 사용하는 것 입니다. 일부 Google 교육 자료 는 동일한 솔루션을 제안합니다.

@Override
public void onClick(View v) {
    my_button.setBackgroundResource(R.drawable.icon);

    Handler handler = new Handler(); 
    handler.postDelayed(new Runnable() {
         @Override 
         public void run() { 
              my_button.setBackgroundResource(R.drawable.defaultcard); 
         } 
    }, 2000); 
}

그러나 일부는 위의 솔루션 이 외부 클래스 인 활동에 대한 참조를 내재적으로 보유하는 비 정적 내부 및 익명 클래스를 사용하기 때문에 메모리 누수가 발생 한다고 지적했습니다 . 활동 컨텍스트가 가비지 수집 될 때 문제가됩니다.

메모리 누설을 방지보다 복잡한 용액, 서브 클래스 Handler및 Runnable그 밖의 클래스 암시 참조지지 않은 정적 내부 클래스 보낸 활동 내부 정적 내부 클래스로 :

private static class MyHandler extends Handler {}
private final MyHandler mHandler = new MyHandler();

public static class MyRunnable implements Runnable {
    private final WeakReference<Activity> mActivity;

    public MyRunnable(Activity activity) {
        mActivity = new WeakReference<>(activity);
    }

    @Override
    public void run() {
        Activity activity = mActivity.get();
        if (activity != null) {
            Button btn = (Button) activity.findViewById(R.id.button);
            btn.setBackgroundResource(R.drawable.defaultcard);
        }
    }
}

private MyRunnable mRunnable = new MyRunnable(this);

public void onClick(View view) {
    my_button.setBackgroundResource(R.drawable.icon);

    // Execute the Runnable in 2 seconds
    mHandler.postDelayed(mRunnable, 2000);
}

참고 것을 Runnable사용하는 WeakReference를 사용자 인터페이스에 대한 액세스를 필요로하는 정적 클래스에 필요한 활동에.

당신은 그것이이 일을 시도 할 수 있습니다 짧은

SystemClock.sleep(7000);

경고 : 절대로 UI 스레드에서 수행하지 마십시오.

이것을 사용하여 잠자십시오. 배경 실.

문제에 대한 전체 솔루션은 다음과 같습니다. 이것은 사용 가능한 API입니다 1

findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(final View button) {
                button.setBackgroundResource(R.drawable.avatar_dead);
                final long changeTime = 1000L;
                button.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        button.setBackgroundResource(R.drawable.avatar_small);
                    }
                }, changeTime);
            }
        });

tmp 핸들러를 작성하지 않고 또한이 솔루션은 @tronman보다 낫습니다. 처리기별로보기를 유지하지 않기 때문입니다. 또한 불량 스레드에서 작성된 Handler에는 문제가 없습니다.)

선적 서류 비치

공공 정적 무효 수면 (긴 ms)

API 레벨 1에 추가됨

돌아 오기 전에 주어진 밀리 초 (uptimeMillis) 동안 기다립니다. sleep (long)과 유사 하지만 InterruptedException을 발생시키지 않습니다 . 다음 인터럽트 가능 조작까지 인터럽트 () 이벤트가 지연됩니다. 않습니다 반환하지 적어도 지정된 밀리 초를 경과 할 때까지.

매개 변수

밀리 초의 가동 시간으로 돌아 오기 전에 ms 가 절전 모드로 전환됩니다.

View 클래스에서 postDelayed 코드 :

/**
 * <p>Causes the Runnable to be added to the message queue, to be run
 * after the specified amount of time elapses.
 * The runnable will be run on the user interface thread.</p>
 *
 * @param action The Runnable that will be executed.
 * @param delayMillis The delay (in milliseconds) until the Runnable
 *        will be executed.
 *
 * @return true if the Runnable was successfully placed in to the
 *         message queue.  Returns false on failure, usually because the
 *         looper processing the message queue is exiting.  Note that a
 *         result of true does not mean the Runnable will be processed --
 *         if the looper is quit before the delivery time of the message
 *         occurs then the message will be dropped.
 *
 * @see #post
 * @see #removeCallbacks
 */
public boolean postDelayed(Runnable action, long delayMillis) {
    final AttachInfo attachInfo = mAttachInfo;
    if (attachInfo != null) {
        return attachInfo.mHandler.postDelayed(action, delayMillis);
    }
    // Assume that post will succeed later
    ViewRootImpl.getRunQueue().postDelayed(action, delayMillis);
    return true;
}

나는 이것을 사용한다 :

Thread closeActivity = new Thread(new Runnable() {
  @Override
  public void run() {
    try {
      Thread.sleep(3000);
      // Do some stuff
    } catch (Exception e) {
      e.getLocalizedMessage();
    }
  }
});

당신은 아마 그렇게하고 싶지 않을 것입니다. sleep()버튼 클릭 이벤트 핸들러에 명시를두면 실제로 전체 UI를 잠깐 잠글 수 있습니다. 한 가지 대안은 일종의 단일 샷 타이머 를 사용하는 것입니다 . 배경색을 다시 기본 색으로 변경하고 타이머에서 예약하려면 TimerTask 를 만듭니다 .

또 다른 가능성은 Handler 를 사용하는 것 입니다. 타이머 사용에서 처리기 사용으로 전환 한 사람에 대한 자습서 가 있습니다 .

또한 프로세스를 일시 중지 할 수 없습니다. Java (또는 Android) 프로세스에는 최소한 하나의 스레드가 있으며 스레드 만 휴면 할 수 있습니다.

CountDownTime을 사용합니다

new CountDownTimer(5000, 1000) {

    @Override
    public void onTick(long millisUntilFinished) {
        // do something after 1s
    }

    @Override
    public void onFinish() {
        // do something end times 5s
    }

}.start(); 

이것은 내가 하루가 끝났을 때 한 일입니다-지금 잘 작동합니다 :

@Override
    public void onClick(View v) {
        my_button.setBackgroundResource(R.drawable.icon);
        // SLEEP 2 SECONDS HERE ...
        final Handler handler = new Handler(); 
        Timer t = new Timer(); 
        t.schedule(new TimerTask() { 
                public void run() { 
                        handler.post(new Runnable() { 
                                public void run() { 
                                 my_button.setBackgroundResource(R.drawable.defaultcard); 
                                } 
                        }); 
                } 
        }, 2000); 
    }

Yankowsky 씨의 답변 외에도을 사용할 수 있습니다 postDelayed(). View카드 (예 : 카드) 에서 사용할 수 있으며 시간이 오래 걸립니다 Runnable. Runnable그 지연 후에 실행합니다 .

이것은 나의 예입니다

자바 유틸리티 만들기

    import android.app.ProgressDialog;
    import android.content.Context;
    import android.content.Intent;

    public class Utils {

        public static void showDummyWaitingDialog(final Context context, final Intent startingIntent) {
            // ...
            final ProgressDialog progressDialog = ProgressDialog.show(context, "Please wait...", "Loading data ...", true);

            new Thread() {
                public void run() {
                    try{
                        // Do some work here
                        sleep(5000);
                    } catch (Exception e) {
                    }
                    // start next intent
                    new Thread() {
                        public void run() {
                        // Dismiss the Dialog 
                        progressDialog.dismiss();
                        // start selected activity
                        if ( startingIntent != null) context.startActivity(startingIntent);
                        }
                    }.start();
                }
            }.start();  

        }

    }    

또는 다음을 사용할 수 있습니다.

android.os.SystemClock.sleep(checkEvery)

이것은 랩핑이 필요없는 장점이 try ... catch있습니다.

코 틀린과 코 루틴 을 사용한다면 간단하게 할 수 있습니다

GlobalScope.launch {
   delay(3000) // In ms
   //Code after sleep
}

UI를 업데이트해야하는 경우

GlobalScope.launch {
  delay(3000)
  GlobalScope.launch(Dispatchers.Main) {
    //Action on UI thread
  }
}

나는 이것이 오래된 스레드라는 것을 알고 있지만 Android 설명서에서 나에게 매우 잘 맞는 솔루션을 찾았습니다 ...

new CountDownTimer(30000, 1000) {

    public void onTick(long millisUntilFinished) {
        mTextField.setText("seconds remaining: " + millisUntilFinished / 1000);
    }

    public void onFinish() {
        mTextField.setText("done!");
    }
}.start();

https://developer.android.com/reference/android/os/CountDownTimer.html

이것이 누군가를 돕기를 바랍니다 ...

  class MyActivity{
    private final Handler handler = new Handler();
    private Runnable yourRunnable;
    protected void onCreate(@Nullable Bundle savedInstanceState) {
       // ....
       this.yourRunnable = new Runnable() {
               @Override
               public void run() {
                   //code
               }
            };

        this.handler.postDelayed(this.yourRunnable, 2000);
       }


     @Override
  protected void onDestroy() {
      // to avoid memory leaks
      this.handler.removeCallbacks(this.yourRunnable);
      }
    }

그리고 tronman 답변에 설명 된대로 "정적 클래스"방법과 결합 할 수 있는지 두 배로하십시오