Come mettere in pausa / sospendere il thread o elaborare in Android?

Voglio fare una pausa tra due righe di codice, lasciami spiegare un po ':

-> l'utente fa clic su un pulsante (una scheda in effetti) e lo faccio vedere cambiando lo sfondo di questo pulsante:

thisbutton.setBackgroundResource(R.drawable.icon);

-> dopo un secondo, devo tornare allo stato precedente del pulsante cambiando il suo sfondo:

thisbutton.setBackgroundResource(R.drawable.defaultcard);

-> Ho provato a mettere in pausa il thread tra queste due righe di codice con:

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

Tuttavia, questo non funziona. Forse è il processo e non il thread che devo mettere in pausa?

Ho anche provato (ma non funziona):

new Reminder(5);

Con questo:

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

Come posso mettere in pausa / mettere in pausa il thread o l'elaborazione?

Una soluzione a questo problema è utilizzare il metodo Handler.postDelayed () . Alcuni materiali di formazione di Google suggeriscono la stessa soluzione.

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

Tuttavia, alcuni hanno sottolineato che la soluzione di cui sopra provoca una perdita di memoria perché utilizza una classe interna e anonima non statica che contiene implicitamente un riferimento alla sua classe esterna, l'attività. Questo è un problema quando il contesto dell'attività è garbage collection.

Una soluzione più complessa che evita la perdita di memoria sottoclassi la Handlere Runnablecon classi interne statiche all'interno dell'attività dal classi interne statiche non contenere un implicito riferimento alla loro classe esterna:

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

Si noti che Runnableutilizza un WeakReference per l'attività, che è necessario in una classe statica che deve accedere all'interfaccia utente.

Puoi provare questo è breve

SystemClock.sleep(7000);

ATTENZIONE : mai e poi mai farlo su un thread dell'interfaccia utente.

Usa questo per dormire ad es. filo di fondo.

La soluzione completa per il tuo problema sarà: questa è l'API 1 disponibile

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

Senza creare il gestore tmp. Anche questa soluzione è migliore di @tronman perché non conserviamo la vista di Handler. Inoltre non abbiamo problemi con Handler creato con thread non validi;)

Documentazione

sleep vuoto statico pubblico (long ms)

Aggiunto nel livello API 1

Attende un determinato numero di millisecondi (di uptimeMillis) prima di tornare. Simile a sleep (long), ma non genera InterruptedException ; gli eventi interrupt () vengono rinviati alla successiva operazione interrompibile. Non restituisce fino a quando non è trascorso almeno il numero di millisecondi specificato.

parametri

ms per dormire prima di tornare, in millisecondi di uptime.

Codice per post Ritardato dalla classe 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;
}

Io lo uso questo:

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

Probabilmente non vorrai farlo in questo modo. Inserendo un esplicito sleep()nel gestore di eventi con clic sul pulsante, si bloccherebbe effettivamente l'intera IU per un secondo. Un'alternativa è usare una sorta di timer a colpo singolo . Creare un TimerTask per riportare il colore di sfondo al colore predefinito e programmarlo sul Timer.

Un'altra possibilità è quella di utilizzare un gestore . C'è un tutorial su qualcuno che è passato dall'uso del timer all'utilizzo di un gestore.

Per inciso, non è possibile mettere in pausa un processo. Un processo Java (o Android) ha almeno 1 thread e puoi solo dormire thread.

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

Questo è quello che ho fatto alla fine della giornata - funziona bene ora:

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

Oltre alle risposte di Mr. Yankowsky, potresti anche usare postDelayed(). Questo è disponibile su qualsiasi View(ad esempio, la tua carta) e richiede un Runnablee un periodo di ritardo. Esegue il Runnableritardo successivo.

Questo è il mio esempio

Crea un Java Utils

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

        }

    }    

Oppure potresti usare:

android.os.SystemClock.sleep(checkEvery)

che ha il vantaggio di non richiedere un avvolgimento try ... catch.

Se usi Kotlin e coroutine , puoi semplicemente farlo

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

E se è necessario aggiornare l'interfaccia utente

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

So che questo è un vecchio thread, ma nella documentazione di Android ho trovato una soluzione che ha funzionato molto bene per me ...

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

Spero che questo aiuti qualcuno ...

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

E per essere doppiamente sicuro, puoi combinarlo con il metodo della "classe statica" come descritto nella risposta tronman