Best Practices for Thread Pausing and Delayed Execution in Android

Introduction

In Android application development, it is often necessary to delay the execution of certain tasks after specific operations, such as displaying temporary state changes following user interactions. Beginners typically attempt to use the Thread.sleep() method to achieve such delays, but this approach has significant drawbacks on the Android platform, particularly when executed on the UI thread, leading to application unresponsiveness.

Limitations of Traditional Methods

Developers initially try to insert delays between UI updates using Thread.sleep(1000):

try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}

The problem with this method is that when Thread.sleep() is called on the UI thread, the entire UI thread becomes blocked, resulting in unrefreshed interfaces and unresponsive user interactions. Even if new background resources are set, the interface does not update immediately because the UI thread is suspended.

Another attempt involves using Timer and TimerTask:

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

Although Timer can work in background threads, it is still not the optimal choice for handling UI-related delayed tasks, especially when UI components need to be updated.

The Handler.postDelayed() Mechanism

Android provides the Handler.postDelayed() method as the standard solution for implementing delayed execution. This method adds a Runnable object to the message queue, executing it after a specified delay:

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

The advantage of this approach is that it does not block the UI thread; instead, it schedules the task for execution at a future time, allowing the UI thread to continue processing other events and interface updates in the meantime.

Memory Leak Issues and Solutions

The simple implementation above carries potential memory leak risks. Non-static inner classes and anonymous classes implicitly hold references to their outer classes (typically Activities). If an Activity is destroyed before the delayed task executes, the Handler and Runnable still hold references, preventing the Activity from being garbage collected.

To address this issue, a combination of static inner classes and weak references can be used:

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);
    mHandler.postDelayed(mRunnable, 2000);
}

In this implementation, static inner classes do not hold references to outer classes, and WeakReference ensures that garbage collection is not prevented when the Activity is destroyed.

Simplified Implementation: View.postDelayed()

For simple UI delay updates, the View.postDelayed() method can further simplify the code:

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

This method avoids explicitly creating Handler instances, resulting in cleaner code while automatically ensuring the Runnable executes on the UI thread.

Delayed Handling in Non-UI Threads

For tasks requiring delayed execution in background threads, SystemClock.sleep() can be used:

SystemClock.sleep(7000);

Unlike Thread.sleep(), SystemClock.sleep() does not throw InterruptedException; interrupt events are deferred until the next interruptible operation. However, it is crucial to note that this method should also not be used on the UI thread.

Modern Alternatives

With the popularity of Kotlin coroutines, developers can adopt more modern asynchronous programming approaches:

lifecycleScope.launch {
    // Update UI
    delay(1000) // Non-blocking delay
    // Operations after delay
}

The delay() function is a suspending function that does not block threads, allowing the UI to remain responsive and redraw during the delay.

Performance Considerations

When handling a large number of concurrent delayed tasks, Thread.sleep() creates numerous threads in waiting states, potentially leading to resource exhaustion. In contrast, using ScheduledExecutorService manages delayed tasks more efficiently:

ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
scheduler.schedule(() -> {
    // Delayed task
}, 1, TimeUnit.SECONDS);

A single scheduler thread can handle thousands of concurrent delayed tasks, significantly improving resource utilization.

Conclusion

When implementing delayed execution in Android development, priority should be given to Handler.postDelayed() or View.postDelayed() for UI-related delayed tasks. For complex scenarios, employing static inner classes and weak references effectively prevents memory leaks. In modern Android development, Kotlin coroutines offer more elegant solutions. Developers should choose appropriate delayed execution strategies based on specific requirements to ensure application performance and user experience.