Android applications should never perform heavy operations on the main UI thread.
Tasks such as:
- Network requests
- File downloads
- Database processing
- Large calculations
can block the UI and make applications unresponsive.
In this tutorial, we will learn how to use AsyncTask in Android to perform background operations while updating the UI safely.
What Is AsyncTask?
AsyncTask is an Android class used to perform background operations and publish results on the UI thread.
It helps developers avoid manually managing:
- Threads
- Handlers
- Runnable objects
Although AsyncTask is deprecated in modern Android development, understanding it is still useful for maintaining older Android projects.
How AsyncTask Works
An AsyncTask typically contains four important methods:
| Method | Purpose |
|---|---|
| onPreExecute() | Runs before background task starts |
| doInBackground() | Performs heavy background work |
| onProgressUpdate() | Updates progress on UI thread |
| onPostExecute() | Returns result to UI thread |
What We Will Build
In this example:
- User clicks a button
- Background task starts
- ProgressBar updates gradually
- Toast message appears after completion
Step 1 — Create Layout File
Create the UI inside activity_main.xml.
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
android:orientation="vertical">
<ProgressBar
android:id="@+id/progress_bar"
style="@style/Widget.AppCompat.ProgressBar.Horizontal"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_margin="16dp"
android:visibility="invisible"/>
<Button
android:id="@+id/button_start"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Start"/>
</LinearLayout>
Step 2 — Implement MainActivity.java
Open MainActivity.java and add the following code:
package com.example.asynctaskexample;
import androidx.appcompat.app.AppCompatActivity;
import android.os.AsyncTask;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.ProgressBar;
import android.widget.Toast;
import java.lang.ref.WeakReference;
public class MainActivity extends AppCompatActivity {
private ProgressBar progressBar;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
progressBar = findViewById(R.id.progress_bar);
Button buttonStart =
findViewById(R.id.button_start);
buttonStart.setOnClickListener(
new View.OnClickListener() {
@Override
public void onClick(View view) {
ExampleAsyncTask task =
new ExampleAsyncTask(
MainActivity.this
);
task.execute(10);
}
});
}
private static class ExampleAsyncTask
extends AsyncTask<Integer, Integer, String> {
private WeakReference<MainActivity>
activityWeakReference;
ExampleAsyncTask(MainActivity activity) {
activityWeakReference =
new WeakReference<>(activity);
}
@Override
protected void onPreExecute() {
super.onPreExecute();
MainActivity activity =
activityWeakReference.get();
if (activity == null
|| activity.isFinishing()) {
return;
}
activity.progressBar
.setVisibility(View.VISIBLE);
}
@Override
protected String doInBackground(
Integer... integers
) {
for (int i = 0;
i < integers[0];
i++) {
publishProgress(
(i * 100) / integers[0]
);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return "Finished!";
}
@Override
protected void onProgressUpdate(
Integer... values
) {
super.onProgressUpdate(values);
MainActivity activity =
activityWeakReference.get();
if (activity == null
|| activity.isFinishing()) {
return;
}
activity.progressBar
.setProgress(values[0]);
}
@Override
protected void onPostExecute(String s) {
super.onPostExecute(s);
MainActivity activity =
activityWeakReference.get();
if (activity == null
|| activity.isFinishing()) {
return;
}
Toast.makeText(
activity,
s,
Toast.LENGTH_SHORT
).show();
activity.progressBar.setProgress(0);
activity.progressBar
.setVisibility(View.INVISIBLE);
}
}
}
Why WeakReference Is Important
AsyncTask can continue running even after the Activity is destroyed.
If developers keep a strong Activity reference, memory leaks can happen.
Using:
WeakReference<MainActivity>
helps prevent memory leaks by allowing Android to clean destroyed Activities properly.
How This Example Works
The workflow is:
- User clicks Start button
- AsyncTask starts in background
- Progress updates every second
- ProgressBar updates on UI thread
- Toast appears after completion
Understanding AsyncTask Generic Types
AsyncTask<Params, Progress, Result>
| Type | Purpose |
|---|---|
| Params | Input parameters |
| Progress | Progress updates |
| Result | Final task result |
Common Mistakes Developers Make
1. Updating UI Inside doInBackground()
UI updates should only happen on the main thread.
2. Creating Memory Leaks
Holding strong Activity references can leak destroyed Activities.
3. Running Heavy Infinite Tasks
Long-running operations should use WorkManager or background services instead.
Why AsyncTask Is Deprecated
Google deprecated AsyncTask because:
- Lifecycle handling is difficult
- Memory leaks are common
- Limited threading flexibility
- Poor scalability
Modern Alternatives to AsyncTask
Modern Android applications should use:
- Coroutines
- WorkManager
- RxJava
- Executors
- LiveData + ViewModel
AsyncTask vs Coroutines
| AsyncTask | Coroutines |
|---|---|
| Deprecated | Modern solution |
| Complex lifecycle handling | Lifecycle-aware support |
| More boilerplate | Cleaner asynchronous code |
FAQ
Is AsyncTask still useful in 2026?
Mainly for maintaining older Android projects and interview preparation.
Why should heavy work avoid the UI thread?
Heavy operations can freeze the UI and cause ANR (Application Not Responding) errors.
What is the best replacement for AsyncTask?
Kotlin Coroutines and WorkManager are modern recommended solutions.
Conclusion
AsyncTask helped Android developers perform background operations more easily in older Android applications.
Although deprecated today, understanding AsyncTask is still useful for maintaining legacy projects and understanding Android threading concepts.
Modern Android applications should prefer lifecycle-aware asynchronous solutions such as Coroutines and WorkManager.
About the Author
Salil Jha is a Full Stack and Mobile Developer with experience in Android, React Native, scalable SaaS platforms, fintech systems, and developer tooling applications.
CodeChain Dev — Build Modern Products. Solve Real Problems.