Як призупинити / спати нитку або обробити в Android?

Я хочу зробити паузу між двома рядками коду. Дозвольте мені трохи пояснити:

-> користувач натискає кнопку (фактично карта), і я показую її, змінюючи фон цієї кнопки:

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використовується слабке посилання на активність, необхідне в статичному класі, якому потрібен доступ до інтерфейсу користувача.

Ви можете спробувати цей короткий

SystemClock.sleep(7000);

ПОПЕРЕДЖЕННЯ . Ніколи і ніколи не робіть цього на потоці інтерфейсу користувача.

Використовуйте це для сну, наприклад. фонова нитка.

Повне рішення вашої проблеми буде: Це доступний 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 Handler. Крім того, це рішення краще, ніж @tronman, оскільки ми не зберігаємо перегляд від Handler. Крім того, у нас немає проблем з Handler, створеним в поганій темі;)

Документація

публічний статичний недійсний сон (тривалий мс)

Додано в рівень 1 API

Зачекає задану кількість мілісекунд (часу без пробілу) перед поверненням. Схожий на сон (тривалий), але не кидає InterruptedException ; події interrupt () відкладаються до наступної операції переривання. Хіба не повернеться до тих пір , по крайней мере, задану кількість мілісекунд , поки не закінчиться.

Параметри

мс для сну перед поверненням, в мілісекундах часу безперервного часу.

Код для публікаціїЗахищено від класу View:

/**
 * <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()в обробник подій, який натиснув кнопку, ви фактично заблокували весь інтерфейс на секунду. Однією з альтернатив є використання якогось таймера для одиночного зйомки . Створіть задачу TimerTask, щоб змінити колір тла до кольору за замовчуванням, і заплануйте його на Таймері.

Інша можливість - використовувати обробник . Там є підручник про того, хто перейшов з таймера на використання обробника.

До речі, ви не можете призупинити процес. Процес Java (або Android) має щонайменше 1 потік, і ви можете спати лише теми.

Я використовую 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); 
    }

Окрім відповідей пана Янковського, ви можете також скористатися postDelayed(). Це доступно на будь-якій View(наприклад, на вашій картці) і потребує Runnableперіоду та затримки. Він виконує Runnableпісля цього затримку.

Це мій приклад

Створіть утиліти Java

    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
}

І якщо вам потрібно оновити інтерфейс користувача

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