Saya ingin dapat memanggil metode berikut setelah penundaan yang ditentukan. Dalam tujuan c ada sesuatu seperti:

[self performSelector:@selector(DoSomething) withObject:nil afterDelay:5];

Apakah ada yang setara dengan metode ini di android dengan java? Misalnya saya harus dapat memanggil metode setelah 5 detik.

public void DoSomething()
{
     //do something here
}

Kotlin

Handler().postDelayed({
  //Do something after 100ms
}, 100)

Jawa

final Handler handler = new Handler();
handler.postDelayed(new Runnable() {
  @Override
  public void run() {
    //Do something after 100ms
  }
}, 100);

Saya tidak dapat menggunakan jawaban lain dalam kasus saya. Saya menggunakan Timer java asli sebagai gantinya.

new Timer().schedule(new TimerTask() {          
    @Override
    public void run() {
        // this code will be executed after 2 seconds       
    }
}, 2000);

Catatan: Jawaban ini diberikan ketika pertanyaan tidak menentukan Android sebagai konteksnya. Untuk jawaban yang spesifik untuk utas Android UI lihat di sini.

Sepertinya Mac OS API memungkinkan utas saat ini berlanjut, dan menjadwalkan tugas untuk berjalan secara tidak sinkron. Di Java, fungsi yang setara disediakan oleh java.util.concurrentpaket. Saya tidak yakin batasan apa yang mungkin diterapkan oleh Android.

private static final ScheduledExecutorService worker = 
  Executors.newSingleThreadScheduledExecutor();

void someMethod() {
  ⋮
  Runnable task = new Runnable() {
    public void run() {
      /* Do something… */
    }
  };
  worker.schedule(task, 5, TimeUnit.SECONDS);
  ⋮
}

Untuk mengeksekusi sesuatu di UI Thread setelah 5 detik:

new Handler(Looper.getMainLooper()).postDelayed(new Runnable() {
    @Override
    public void run() {
        //Do something here
    }
}, 5000);

Anda dapat menggunakan Handler di dalam UIThread:

runOnUiThread(new Runnable() {

    @Override
    public void run() {
         final Handler handler = new Handler();
         handler.postDelayed(new Runnable() {
           @Override
           public void run() {
               //add your code here
           }
         }, 1000);

    }
});

Terima kasih atas semua jawaban hebatnya, saya menemukan solusi yang paling sesuai dengan kebutuhan saya.

Handler myHandler = new DoSomething();
Message m = new Message();
m.obj = c;//passing a parameter here
myHandler.sendMessageDelayed(m, 1000);

class DoSomething extends Handler {
    @Override
    public void handleMessage(Message msg) {
      MyObject o = (MyObject) msg.obj;
      //do something here
    }
}

Kotlin& JavaBanyak Cara

1. Menggunakan Handler

Handler().postDelayed({
    TODO("Do something")
    }, 2000)

2. Menggunakan TimerTask

Timer().schedule(object : TimerTask() {
    override fun run() {
        TODO("Do something")
    }
}, 2000)

Atau bahkan lebih pendek

Timer().schedule(timerTask {
    TODO("Do something")
}, 2000)

Atau terpendek

Timer().schedule(2000) {
    TODO("Do something")
}

3. Menggunakan Executors

Executors.newSingleThreadScheduledExecutor().schedule({
    TODO("Do something")
}, 2, TimeUnit.SECONDS)

Di jawa

1. Menggunakan Handler

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        //Do something
    }
}, 2000);

2. Menggunakan Timer

new Timer().schedule(new TimerTask() {          
    @Override
    public void run() {
        // Do something
    }
}, 2000);

3. Menggunakan ScheduledExecutorService

private static final ScheduledExecutorService worker = Executors.newSingleThreadScheduledExecutor();

Runnable runnable = new Runnable() {
  public void run() {
      // Do something
  }
  };
worker.schedule(runnable, 2, TimeUnit.SECONDS);

Lihat demo ini:

import java.util.Timer;
import java.util.TimerTask;

class Test {
     public static void main( String [] args ) {
          int delay = 5000;// in ms 

          Timer timer = new Timer();

          timer.schedule( new TimerTask(){
             public void run() { 
                 System.out.println("Wait, what..:");
              }
           }, delay);

           System.out.println("Would it run?");
     }
}

Jika Anda harus menggunakan Handler, tetapi Anda berada di utas lain, Anda dapat menggunakan runonuithreaduntuk menjalankan handler di utas UI. Ini akan menyelamatkan Anda dari Pengecualian yang diajukan untuk meneleponLooper.Prepare()

runOnUiThread(new Runnable() {
    @Override
    public void run() {
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                //Do something after 1 second
            }
        }, 1000);
    }
});

Terlihat sangat berantakan, tetapi ini adalah salah satu caranya.

Saya lebih suka menggunakan View.postDelayed()metode, kode sederhana di bawah ini:

mView.postDelayed(new Runnable() {
    @Override
    public void run() {
        // Do something after 1000 ms
    }
}, 1000);

Inilah solusi terpendek saya:

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        //Do something after 100ms
    }
}, 100);

final Handler handler = new Handler(); 
Timer t = new Timer(); 
t.schedule(new TimerTask() { 
    public void run() { 
        handler.post(new Runnable() { 
            public void run() { 
                //DO SOME ACTIONS HERE , THIS ACTIONS WILL WILL EXECUTE AFTER 5 SECONDS...
            }
        }); 
    } 
}, 5000); 

Jika Anda menggunakan Android Studio 3.0 dan di atasnya, Anda dapat menggunakan ekspresi lambda. Metode callMyMethod()ini dipanggil setelah 2 detik:

new Handler().postDelayed(() -> callMyMethod(), 2000);

Jika Anda perlu membatalkan runnable yang tertunda gunakan ini:

Handler handler = new Handler();
handler.postDelayed(() -> callMyMethod(), 2000);

// When you need to cancel all your posted runnables just use:
handler.removeCallbacksAndMessages(null);

Saya menyarankan Timer , ini memungkinkan Anda untuk menjadwalkan metode yang akan dipanggil pada interval yang sangat spesifik. Ini tidak akan memblokir UI Anda, dan menjaga aplikasi Anda tetap beresonansi saat metode ini dijalankan.

Opsi lainnya, adalah wait (); metode, ini akan memblokir utas saat ini untuk jangka waktu yang ditentukan. Ini akan menyebabkan UI Anda berhenti merespons jika Anda melakukan ini pada utas UI.

Untuk tunda Post Menangani garis Sederhana, Anda dapat melakukan hal berikut:

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        // Do someting
    }
}, 3000);

saya harap ini membantu

Anda dapat menggunakan ini untuk Solusi Sederhana:

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        //Write your code here
    }
}, 5000); //Timer is in ms here.

Lain, Di bawah ini bisa menjadi solusi bersih yang bermanfaat:

new Handler().postDelayed(() -> 
{/*Do something here*/}, 
5000); //time in ms

Anda dapat membuatnya lebih bersih dengan menggunakan ekspresi lambda yang baru diperkenalkan:

new Handler().postDelayed(() -> {/*your code here*/}, time);

Jadi ada beberapa hal yang perlu dipertimbangkan di sini karena ada begitu banyak cara untuk menguliti kucing ini. Meskipun semua jawaban sudah diberikan dipilih dan dipilih. Saya pikir ini penting bahwa ini akan ditinjau kembali dengan pedoman pengkodean yang tepat untuk menghindari orang salah arah hanya karena "jawaban sederhana yang dipilih mayoritas".

Jadi pertama-tama mari kita bahas jawaban sederhana Post Delayed yaitu jawaban yang dipilih secara keseluruhan di utas ini.

Beberapa hal yang perlu dipertimbangkan. Setelah jeda posting, Anda dapat menemukan kebocoran memori, benda mati, siklus hidup yang telah hilang, dan banyak lagi. Jadi penanganannya dengan benar juga penting. Anda dapat melakukan ini dalam beberapa cara.

Demi perkembangan modern, saya akan memasok di KOTLIN

Berikut adalah contoh sederhana menggunakan utas UI pada panggilan balik dan mengonfirmasi bahwa aktivitas Anda masih hidup dan baik ketika Anda menekan panggilan balik Anda.

  Handler(Looper.getMainLooper()).postDelayed({
            if(activity != null && activity?.isFinishing == false){
                txtNewInfo.visibility = View.GONE
            }
        }, NEW_INFO_SHOW_TIMEOUT_MS)

Namun, ini masih belum sempurna karena tidak ada alasan untuk menelepon balik Anda jika aktivitas telah hilang. jadi cara yang lebih baik adalah menyimpan referensi dan menghapus callbacknya seperti ini.

    private fun showFacebookStylePlus1NewsFeedOnPushReceived(){
        A35Log.v(TAG, "showFacebookStylePlus1NewsFeedOnPushReceived")
        if(activity != null && activity?.isFinishing == false){
            txtNewInfo.visibility = View.VISIBLE
            mHandler.postDelayed({
                if(activity != null && activity?.isFinishing == false){
                    txtNewInfo.visibility = View.GONE
                }
            }, NEW_INFO_SHOW_TIMEOUT_MS)
        }
    }

dan tentu saja menangani pembersihan pada onPause sehingga tidak menekan callback.

    override fun onPause() {
        super.onPause()
        mHandler.removeCallbacks(null)
    }

Sekarang kita telah membahas yang jelas, mari kita bicara tentang opsi yang lebih bersih dengan coroutine dan kotlin modern :). Jika Anda belum menggunakannya, Anda benar-benar ketinggalan.

   fun doActionAfterDelay() 
        launch(UI) {
            delay(MS_TO_DELAY)           
            actionToTake()
        }
    }

atau jika Anda ingin selalu melakukan peluncuran UI pada metode itu, Anda cukup melakukannya:

  fun doActionAfterDelay() = launch(UI){ 
      delay(MS_TO_DELAY)           
      actionToTake()
  }

Tentu saja sama seperti PostDelayed Anda harus memastikan Anda menangani pembatalan sehingga Anda dapat melakukan pemeriksaan aktivitas setelah panggilan tunda atau Anda dapat membatalkannya di onPause sama seperti rute lainnya.

var mDelayedJob: Job? = null
fun doActionAfterDelay() 
   mDelayedJob = launch(UI) {
            try {
               delay(MS_TO_DELAY)           
               actionToTake()
            }catch(ex: JobCancellationException){
                showFancyToast("Delayed Job canceled", true, FancyToast.ERROR, "Delayed Job canceled: ${ex.message}")
            }
        }
   }
}

// menangani pembersihan

override fun onPause() {
   super.onPause()
   if(mDelayedJob != null && mDelayedJob!!.isActive) {
      A35Log.v(mClassTag, "canceling delayed job")
      mDelayedJob?.cancel() //this should throw CancelationException in coroutine, you can catch and handle appropriately
   }
}

Jika Anda memasukkan peluncuran (UI) ke dalam metode tanda tangan, pekerjaan itu dapat ditetapkan dalam baris kode panggilan.

jadi moral dari cerita ini adalah untuk aman dengan tindakan Anda yang tertunda, pastikan Anda menghapus panggilan balik Anda, atau membatalkan pekerjaan Anda dan tentu saja mengkonfirmasi Anda memiliki siklus hidup yang tepat untuk menyentuh item pada penundaan panggilan balik Anda selesai. Coroutine juga menawarkan tindakan yang dapat dibatalkan.

Juga patut dicatat bahwa Anda biasanya harus menangani berbagai pengecualian yang dapat terjadi pada coroutine. Misalnya, pembatalan, pengecualian, batas waktu, apa pun yang Anda putuskan untuk digunakan. Ini adalah contoh yang lebih maju jika Anda memutuskan untuk benar-benar mulai menggunakan coroutine.

   mLoadJob = launch(UI){
            try {
                //Applies timeout
                withTimeout(4000) {
                    //Moves to background thread
                    withContext(DefaultDispatcher) {
                        mDeviceModelList.addArrayList(SSDBHelper.getAllDevices())
                    }
                }

                //Continues after async with context above
                showFancyToast("Loading complete", true, FancyToast.SUCCESS)
            }catch(ex: JobCancellationException){
                showFancyToast("Save canceled", true, FancyToast.ERROR, "Save canceled: ${ex.message}")
            }catch (ex: TimeoutCancellationException) {
                showFancyToast("Timed out saving, please try again or press back", true, FancyToast.ERROR, "Timed out saving to database: ${ex.message}")
            }catch(ex: Exception){
                showFancyToast("Error saving to database, please try again or press back", true, FancyToast.ERROR, "Error saving to database: ${ex.message}")
            }
        }

Saya membuat metode yang lebih sederhana untuk menyebutnya.

public static void CallWithDelay(long miliseconds, final Activity activity, final String methodName)
    {
        new Handler().postDelayed(new Runnable() {

            @Override
            public void run() {
                try {
                    Method method =  activity.getClass().getMethod(methodName);
                    method.invoke(activity);
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }, miliseconds);
    }

Untuk menggunakannya, cukup hubungi: .CallWithDelay(5000, this, "DoSomething");

Di bawah satu berfungsi saat Anda mendapatkan,

java.lang.RuntimeException: Tidak dapat membuat handler di dalam utas yang belum disebut Looper.prepare ()

final Handler handler = new Handler(Looper.getMainLooper());
handler.postDelayed(new Runnable() {
  @Override
  public void run() {
    //Do something after 100ms
  }
}, 100);

Menggunakan Kotlin, kita dapat mencapai dengan melakukan hal berikut

Handler().postDelayed({
    // do something after 1000ms 
}, 1000)

Sangat mudah menggunakan CountDownTimer. Untuk detail lebih lanjut https://developer.android.com/reference/android/os/CountDownTimer.html

import android.os.CountDownTimer;

// calls onTick every second, finishes after 3 seconds
new CountDownTimer(3000, 1000) { 

   public void onTick(long millisUntilFinished) {
      Log.d("log", millisUntilFinished / 1000);
   }

   public void onFinish() {
      // called after count down is finished
   } 
}.start();

Jika Anda menggunakan RxAndroid maka penanganan thread dan kesalahan menjadi jauh lebih mudah. Kode berikut dijalankan setelah penundaan

   Observable.timer(delay, TimeUnit.SECONDS)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(aLong -> {
           // Execute code here
        }, Throwable::printStackTrace);

semua orang tampaknya lupa untuk membersihkan Handler sebelum memposting runnable baru atau pesan di atasnya. Selain itu mereka berpotensi menumpuk dan menyebabkan perilaku buruk.

handler.removeMessages(int what);
// Remove any pending posts of messages with code 'what' that are in the message queue.

handler.removeCallbacks(Runnable r)
// Remove any pending posts of Runnable r that are in the message queue.

Berikut ini cara rumit lainnya: itu tidak akan membuang pengecualian ketika runnable mengubah elemen UI.

public class SimpleDelayAnimation extends Animation implements Animation.AnimationListener {

    Runnable callBack;

    public SimpleDelayAnimation(Runnable runnable, int delayTimeMilli) {
        setDuration(delayTimeMilli);
        callBack = runnable;
        setAnimationListener(this);
    }

    @Override
    public void onAnimationStart(Animation animation) {

    }

    @Override
    public void onAnimationEnd(Animation animation) {
        callBack.run();
    }

    @Override
    public void onAnimationRepeat(Animation animation) {

    }
}

Anda dapat memanggil animasi seperti ini:

view.startAnimation(new SimpleDelayAnimation(delayRunnable, 500));

Animasi dapat dilampirkan ke tampilan apa pun.

Inilah jawaban di Kotlin Anda orang-orang malas, malas:

Handler().postDelayed({
//doSomethingHere()
}, 1000)

Saya suka hal-hal yang lebih bersih: Ini adalah implementasi saya, kode inline untuk digunakan di dalam metode Anda

new Handler().postDelayed(new Runnable() {
  @Override
  public void run() {
    //Do something after 100ms
  }
}, 100);

Solusi yang cocok di android:

private static long SLEEP_TIME = 2 // for 2 second
.
.
MyLauncher launcher = new MyLauncher();
            launcher.start();
.
.
private class MyLauncher extends Thread {
        @Override
        /**
         * Sleep for 2 seconds as you can also change SLEEP_TIME 2 to any. 
         */
        public void run() {
            try {
                // Sleeping
                Thread.sleep(SLEEP_TIME * 1000);
            } catch (Exception e) {
                Log.e(TAG, e.getMessage());
            }
            //do something you want to do
           //And your code will be executed after 2 second
        }
    }

Solusi serupa tetapi lebih bersih untuk digunakan

Tulis fungsi ini di luar kelas

fun delay(duration: Long, `do`: () -> Unit) {

    Handler().postDelayed(`do`, duration)

}

Pemakaian:

delay(5000) {
    //Do your work here
}

Di Android, kita dapat menulis kode kotlin di bawah ini untuk menunda eksekusi fungsi apa pun

class MainActivity : AppCompatActivity() {

private lateinit var handler: Handler

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    handler= Handler()
    handler.postDelayed({
        doSomething()
    },2000)
}

private fun doSomething() {
    Toast.makeText(this,"Hi! I am Toast Message",Toast.LENGTH_SHORT).show()
}
}