Bagaimana cara menghentikan / memproses utas atau proses di Android?

Saya ingin membuat jeda di antara dua baris kode, Biarkan saya jelaskan sedikit:

-> pengguna mengklik tombol (kartu sebenarnya) dan saya menunjukkannya dengan mengubah latar belakang tombol ini:

thisbutton.setBackgroundResource(R.drawable.icon);

-> setelah misalkan 1 detik, saya harus kembali ke keadaan tombol sebelumnya dengan mengubah latar belakangnya:

thisbutton.setBackgroundResource(R.drawable.defaultcard);

-> Saya sudah mencoba menjeda utas antara dua baris kode ini dengan:

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

Namun, ini tidak berhasil. Mungkin prosesnya dan bukan Thread yang perlu saya hentikan?

Saya juga sudah mencoba (tetapi tidak berhasil):

new Reminder(5);

Dengan ini:

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

Bagaimana saya bisa menjeda / tidur utas atau proses?

Salah satu solusi untuk masalah ini adalah dengan menggunakan metode Handler.postDelayed () . Beberapa materi pelatihan Google menyarankan solusi yang sama.

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

Namun, beberapa telah menunjukkan bahwa solusi di atas menyebabkan kebocoran memori karena menggunakan kelas non-statis dalam dan anonim yang secara implisit memegang referensi ke kelas luarnya, aktivitas. Ini adalah masalah ketika konteks aktivitasnya adalah pengumpulan sampah.

Solusi yang lebih kompleks yang menghindari kebocoran memori mengelompokkan Handlerdan Runnabledengan kelas dalam statis di dalam aktivitas karena kelas statis dalam tidak memegang referensi implisit ke kelas luar mereka:

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

Perhatikan bahwa Runnablemenggunakan WeakReference to Activity, yang diperlukan di kelas statis yang membutuhkan akses ke UI.

Anda dapat mencoba yang ini pendek

SystemClock.sleep(7000);

PERINGATAN : Tidak pernah, lakukan ini di utas UI.

Gunakan ini untuk tidur misalnya. utas latar belakang.

Solusi lengkap untuk masalah Anda adalah: Ini tersedia 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);
            }
        });

Tanpa membuat tmp Handler. Juga solusi ini lebih baik daripada @tronman karena kami tidak mempertahankan pandangan oleh Handler. Juga kami tidak memiliki masalah dengan Handler dibuat di utas buruk;)

Dokumentasi

public static void sleep (panjang ms)

Ditambahkan di API level 1

Menunggu sejumlah milidetik (dari uptimeMillis) sebelum kembali. Mirip dengan tidur (lama), tetapi tidak membuang InterruptedException ; interrupt () peristiwa ditunda hingga operasi interruptible berikutnya. Tidak kembali sampai setidaknya jumlah milidetik yang ditentukan telah berlalu.

Parameter

ms untuk tidur sebelum kembali, dalam waktu milidetik uptime.

Kode untuk postDelayed dari 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;
}

Saya menggunakan ini:

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

Anda mungkin tidak ingin melakukannya dengan cara itu. Dengan menempatkan eksplisit sleep()di pengendali event yang diklik tombol Anda, Anda benar-benar akan mengunci seluruh UI selama satu detik. Salah satu alternatif adalah menggunakan semacam Timer sekali pakai . Buat TimerTask untuk mengubah warna latar belakang kembali ke warna default, dan jadwalkan pada Timer.

Kemungkinan lain adalah menggunakan Handler . Ada tutorial tentang seseorang yang beralih dari menggunakan Timer ke menggunakan Handler.

Secara kebetulan, Anda tidak dapat menjeda proses. Proses Java (atau Android) memiliki setidaknya 1 utas, dan Anda hanya dapat tidur utas.

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

Inilah yang saya lakukan pada akhir hari - bekerja dengan baik sekarang:

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

Selain jawaban Mr. Yankowsky, Anda juga bisa menggunakan postDelayed(). Ini tersedia pada semua View(mis. Kartu Anda) dan membutuhkan waktu Runnabledan penundaan. Itu mengeksekusi Runnablesetelah penundaan itu.

Ini adalah contoh saya

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

        }

    }    

Atau Anda bisa menggunakan:

android.os.SystemClock.sleep(checkEvery)

yang memiliki keuntungan tidak memerlukan pembungkus try ... catch.

Jika Anda menggunakan Kotlin dan coroutine , Anda bisa melakukannya

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

Dan jika Anda perlu memperbarui UI

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

Saya tahu ini adalah utas lama, tetapi dalam dokumentasi Android saya menemukan solusi yang bekerja sangat baik untuk saya ...

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

Semoga ini bisa membantu seseorang ...

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

Dan untuk menjadi dobel yakin Anda dapat dikombinasikan dengan metode "kelas statis" seperti yang dijelaskan dalam jawaban tronman