Android'de iş parçacığı duraklatma / uyku veya işlem nasıl yapılır?

İki satır kod arasında bir duraklama yapmak istiyorum, biraz açıklayayım:

-> kullanıcı bir düğmeyi tıklar (aslında bir kart) ve bu düğmenin arka planını değiştirerek gösteririm:

thisbutton.setBackgroundResource(R.drawable.icon);

-> diyelim 1 saniye sonra, arka planını değiştirerek düğmenin önceki durumuna geri dönmem gerekiyor:

thisbutton.setBackgroundResource(R.drawable.defaultcard);

-> Bu iki kod satırı arasındaki konuyu duraklatmaya çalıştım:

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

Ancak, bu işe yaramaz. Belki duraklatmam gereken İş Parçası değil, süreç budur?

Ben de denedim (ama çalışmıyor):

new Reminder(5);

Bununla:

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

İpliği veya işlemi nasıl duraklatabilir / uyuyabilirim?

Bu sorunun bir çözümü Handler.postDelayed () yöntemini kullanmaktır. Bazı Google eğitim materyalleri aynı çözümü önerir.

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

Bununla birlikte, bazıları, yukarıdaki çözümün , dış sınıfına, etkinliğine dolaylı olarak referansta bulunan statik olmayan bir iç ve anonim sınıf kullandığından bir bellek sızıntısına neden olduğuna dikkat çekmiştir. Etkinlik bağlamı çöp toplandığında bu bir sorundur.

Bellek kaçağını önlemeye daha karmaşık bir çözelti alt sınıfları Handlerve Runnablebunların dış sınıf örtülü bir referans sahip olmayan statik iç sınıflar yana aktivitesi içindeki statik iç sınıfları ile:

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

Kullanıcı arabirimine erişmesi gereken statik bir sınıfta gerekli olan Etkinliğe WeakReferenceRunnable kullandığını unutmayın .

Bunu deneyebilirsiniz kısa

SystemClock.sleep(7000);

UYARI : Bunu asla bir UI iş parçacığında yapmayın.

Bunu uyku için kullanın örn. arka plan iş parçacığı.

Sorununuz için tam çözüm olacak: Bu kullanılabilir 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 oluşturmadan. Ayrıca bu çözüm @tronman'dan daha iyidir çünkü Handler'ın görüşünü korumazız. Ayrıca kötü iş parçacığında oluşturulan Handler ile sorunumuz yok;)

belgeleme

genel statik boşluk uyku (uzun ms)

API seviye 1'de eklendi

Dönmeden önce belirli bir milisaniye (uptimeMillis) bekler. Uykuya benzer (uzun), ancak InterruptedException'ı atmaz ; interrupt () olayları bir sonraki kesilebilir işleme kadar ertelenir. Does döndürmez en az milisaniye belirtilen sayıda geçene kadar.

Parametreler

ms dönmeden önce uyku, milisaniye çalışma süresi içinde.

View sınıfından postDelayed kodu :

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

Bunu kullanıyorum:

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

Muhtemelen böyle yapmak istemezsiniz. sleep()Düğmeye tıklanmış olay işleyicinize açık bir şekilde koyarak , tüm kullanıcı arayüzünü bir saniyeliğine kilitlersiniz. Bir alternatif, bir çeşit tek-çekim Zamanlayıcı kullanmaktır . Arka plan rengini varsayılan renge geri döndürmek için bir TimerTask oluşturun ve Timer'da zamanlayın.

Başka bir olasılık bir Handler kullanmaktır . Orada bir öğretici Eylemciler kullanarak bir Timer kullanarak anahtarlamalı biri hakkında.

Bu arada, bir işlemi duraklatamazsınız. Bir Java (veya Android) işleminde en az 1 iş parçacığı vardır ve yalnızca iş parçacıklarını uyku moduna alabilirsiniz.

CountDownTime kullanıyorum

new CountDownTimer(5000, 1000) {

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

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

}.start(); 

Günün sonunda bunu yaptım - şimdi iyi çalışıyor:

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

Bay Yankowsky'nin cevaplarına ek olarak kullanabilirsiniz postDelayed(). Bu, herhangi bir View(örneğin kartınız) için geçerlidir ve a Runnableve gecikme süresi alır. Bu Runnablegecikmeden sonra yürütür .

Bu benim örneğim

Java Yardımcı Programları Oluşturma

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

        }

    }    

Veya şunları kullanabilirsiniz:

android.os.SystemClock.sleep(checkEvery)

bir sargı gerektirmeme avantajına sahiptir try ... catch.

Kotlin ve coroutines kullanıyorsanız ,

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

Kullanıcı arayüzünü güncellemeniz gerekiyorsa

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

Bunun eski bir iş parçacığı olduğunu biliyorum, ancak Android belgelerinde benim için çok iyi çalışan bir çözüm buldum ...

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

Umarım bu birine yardımcı olur ...

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

Ve iki kat olmak için, tronman cevabında açıklandığı gibi "statik sınıf" yöntemiyle birleştirilebileceğinden emin olun.