इसे करने के 3 तरीके हैं:
ScheduledThreadPoolExecutor का उपयोग करें
थ्रेड के एक पूल की जरूरत नहीं है क्योंकि आप overkill का एक सा है
//----------------------SCHEDULER-------------------------
private final ScheduledThreadPoolExecutor executor_ =
new ScheduledThreadPoolExecutor(1);
ScheduledFuture<?> schedulerFuture;
public void startScheduler() {
schedulerFuture= executor_.scheduleWithFixedDelay(new Runnable() {
@Override
public void run() {
//DO YOUR THINGS
pageIndexSwitcher.setVisibility(View.GONE);
}
}, 0L, 5*MILLI_SEC, TimeUnit.MILLISECONDS);
}
public void stopScheduler() {
pageIndexSwitcher.setVisibility(View.VISIBLE);
schedulerFuture.cancel(false);
startScheduler();
}
टाइमर टास्क का उपयोग करें
पुरानी Android शैली
//----------------------TIMER TASK-------------------------
private Timer carousalTimer;
private void startTimer() {
carousalTimer = new Timer(); // At this line a new Thread will be created
carousalTimer.scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
//DO YOUR THINGS
pageIndexSwitcher.setVisibility(INVISIBLE);
}
}, 0, 5 * MILLI_SEC); // delay
}
void stopTimer() {
carousalTimer.cancel();
}
हैंडलर और रननेबल का उपयोग करें
आधुनिक Android शैली
//----------------------HANDLER-------------------------
private Handler taskHandler = new android.os.Handler();
private Runnable repeatativeTaskRunnable = new Runnable() {
public void run() {
//DO YOUR THINGS
}
};
void startHandler() {
taskHandler.postDelayed(repeatativeTaskRunnable, 5 * MILLI_SEC);
}
void stopHandler() {
taskHandler.removeCallbacks(repeatativeTaskRunnable);
}
गतिविधि / संदर्भ के साथ गैर-लीक हैंडलर
एक आंतरिक हैंडलर वर्ग की घोषणा करें जो आपकी गतिविधि / फ्रैगमेंट वर्ग में मेमोरी को लीक नहीं करता है
/**
* Instances of static inner classes do not hold an implicit
* reference to their outer class.
*/
private static class NonLeakyHandler extends Handler {
private final WeakReference<FlashActivity> mActivity;
public NonLeakyHandler(FlashActivity activity) {
mActivity = new WeakReference<FlashActivity>(activity);
}
@Override
public void handleMessage(Message msg) {
FlashActivity activity = mActivity.get();
if (activity != null) {
// ...
}
}
}
एक भगोड़ा घोषित करें जो आपके गतिविधि / फ्रैगमेंट वर्ग में आपके दोहराए गए कार्य को पूरा करेगा
private Runnable repeatativeTaskRunnable = new Runnable() {
public void run() {
new Handler(getMainLooper()).post(new Runnable() {
@Override
public void run() {
//DO YOUR THINGS
}
};
अपने एक्टिविटी / फ्रैगमेंट में हैंडलर ऑब्जेक्ट को इनिशियलाइज़ करें (यहाँ FlashActivity मेरी एक्टिविटी क्लास है)
//Task Handler
private Handler taskHandler = new NonLeakyHandler(FlashActivity.this);
समय अंतराल के बाद किसी कार्य को दोहराने के लिए
taskHandler.postDelayed (repeatativeTaskRunnable, DELAY_MILLIS);
कार्य की पुनरावृत्ति को रोकने के लिए
taskHandler .removeCallbacks (repeatativeTaskRunnable);
अद्यतन: कोटलिन में:
//update interval for widget
override val UPDATE_INTERVAL = 1000L
//Handler to repeat update
private val updateWidgetHandler = Handler()
//runnable to update widget
private var updateWidgetRunnable: Runnable = Runnable {
run {
//Update UI
updateWidget()
// Re-run it after the update interval
updateWidgetHandler.postDelayed(updateWidgetRunnable, UPDATE_INTERVAL)
}
}
// SATART updating in foreground
override fun onResume() {
super.onResume()
updateWidgetHandler.postDelayed(updateWidgetRunnable, UPDATE_INTERVAL)
}
// REMOVE callback if app in background
override fun onPause() {
super.onPause()
updateWidgetHandler.removeCallbacks(updateWidgetRunnable);
}