Jak wstrzymać / uśpić wątek lub przetworzyć w Androidzie?

Chcę zrobić przerwę między dwoma wierszami kodu, Pozwól, że wyjaśnię trochę:

-> użytkownik klika przycisk (w rzeczywistości karta) i pokazuję go, zmieniając tło tego przycisku:

thisbutton.setBackgroundResource(R.drawable.icon);

-> po powiedzmy 1 sekundę, muszę wrócić do poprzedniego stanu przycisku, zmieniając tło:

thisbutton.setBackgroundResource(R.drawable.defaultcard);

-> Próbowałem wstrzymać wątek między tymi dwoma wierszami kodu za pomocą:

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

To jednak nie działa. Może to proces, a nie Wątek, który muszę zatrzymać?

Próbowałem też (ale to nie działa):

new Reminder(5);

Z tym:

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

Jak mogę zatrzymać / uśpić wątek lub proces?

Jednym z rozwiązań tego problemu jest użycie metody Handler.postDelayed () . Niektóre materiały szkoleniowe Google sugerują to samo rozwiązanie.

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

Jednak niektórzy zauważyli, że powyższe rozwiązanie powoduje wyciek pamięci, ponieważ wykorzystuje niestatyczną wewnętrzną i anonimową klasę, która domyślnie zawiera odniesienie do swojej klasy zewnętrznej, działania. Jest to problem, gdy kontekst działania jest odśmiecany.

Bardziej złożone rozwiązanie pozwalające uniknąć wycieku pamięci podklas Handleri Runnableze statycznymi klasami wewnętrznymi wewnątrz działania, ponieważ statyczne klasy wewnętrzne nie zawierają niejawnego odniesienia do ich klasy zewnętrznej:

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

Zauważ, że Runnableużywa WeakReference do działania, co jest konieczne w klasie statycznej, która potrzebuje dostępu do interfejsu użytkownika.

Możesz spróbować tego, który jest krótki

SystemClock.sleep(7000);

OSTRZEŻENIE : Nigdy nie rób tego w wątku interfejsu użytkownika.

Użyj tego do spania np. wątek tła.

Pełne rozwiązanie Twojego problemu będzie: To jest dostępne 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);
            }
        });

Bez tworzenia modułu obsługi tmp. Również to rozwiązanie jest lepsze niż @tronman, ponieważ nie zachowujemy widoku Handlera. Nie mamy też problemu z Handlerem stworzonym przy złym wątku;)

Dokumentacja

publiczny statyczny brak snu (długie ms)

Dodano w interfejsie API poziomu 1

Czeka określoną liczbę milisekund (uptimeMillis) przed powrotem. Podobny do uśpienia (długi), ale nie zgłasza wyjątku InterruptedException ; zdarzenia interrupt () są odraczane do następnej operacji przerywanej. Nie zwraca wartości, dopóki nie upłynie przynajmniej określona liczba milisekund.

Parametry

ms do spania przed powrotem, w milisekundach bezawaryjności.

Kod dla postDelayed from View class:

/**
 * <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;
}

Używam tego:

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

Prawdopodobnie nie chcesz tego robić w ten sposób. Umieszczając wyraźny element sleep()w module obsługi zdarzeń klikniętym przyciskiem, faktycznie zablokowałbyś cały interfejs użytkownika na sekundę. Jedną z możliwości jest użycie timera z jednym strzałem . Utwórz TimerTask, aby zmienić kolor tła z powrotem na domyślny, i zaplanuj go w Timerze.

Inną możliwością jest użycie modułu obsługi . Jest tutorial o kimś, kto przeszedł z używania Timera na Handler.

Nawiasem mówiąc, nie można wstrzymać procesu. Proces Java (lub Android) ma co najmniej 1 wątek i możesz tylko uśpić wątki.

Używam 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(); 

To właśnie zrobiłem pod koniec dnia - teraz działa dobrze:

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

Oprócz odpowiedzi pana Jankowskiego można również użyć postDelayed(). Jest to dostępne na dowolnej Viewkarcie (np. Na karcie) i trwa pewien Runnableokres. Wykonuje Runnablepo tym opóźnieniu.

To jest mój przykład

Utwórz narzędzia 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();  

        }

    }    

Lub możesz użyć:

android.os.SystemClock.sleep(checkEvery)

co ma tę zaletę, że nie wymaga pakowania try ... catch.

Jeśli używasz Kotlina i coroutines , możesz po prostu to zrobić

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

A jeśli musisz zaktualizować interfejs użytkownika

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

Wiem, że to stary wątek, ale w dokumentacji Androida znalazłem rozwiązanie, które działało dla mnie bardzo dobrze ...

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

Mam nadzieję, że to pomoże komuś ...

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

Aby mieć pewność, że można go połączyć z metodą „klasy statycznej”, jak opisano w odpowiedzi tronmana