readerlook-tech
Technology

Top Android Interview Questions on AsyncTask

6 Mins read

You have seen many articles related to android interview Q&A but they all not give you proper android interview Q&A, so in this article, I going to share my experience which I gained from giving and taking lots of the interviews of Android Engineer.

Here in this article, I am going to focus on AsyncTask because there is a 90% chances to ask the questions related to AsyncTask in every Interview of Android Engineer and I try to cover all the possible question related to AsyncTask, so stay with me.


What is AsyncTask?

It is an android framework API that uses for short background operations and IPC(inter-process communication)  which means we can communicate between the main thread and background thread provided by Asynctask API.

Under the hood of any multithreading API, uses the Thread class is as per the requirement and if any of these API also provides background thread and main thread IPC they used the combination of thread class and handler in android.

Let’s see, how to use AsyncTask



import android.os.AsyncTask
import android.os.Bundle
import android.os.SystemClock
import android.widget.Button
import android.widget.ProgressBar
import androidx.appcompat.app.AppCompatActivity

class MainActivity : AppCompatActivity() {

    lateinit var mProgressBar: ProgressBar
    lateinit var button: Button
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        mProgressBar = findViewById(R.id.progress_horizontal)

        button = findViewById(R.id.btn)

        button.setOnClickListener {

            MAsyncTask().execute(10);
        }
    }


    private inner class MAsyncTask : AsyncTask<Int, Int, Void>() {
        override fun doInBackground(vararg values: Int?): Void? {
            for (i in 0..values[0]!!) {
                publishProgress(i)
                SystemClock.sleep(500)
            }
            return null

        }

        override fun onProgressUpdate(vararg values: Int?) {
            mProgressBar.progress = values[0]!!

        }

    }
}

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#C8C7C4"
    android:gravity="center"
    android:orientation="vertical"
    android:padding="16dp"
    tools:context=".MainActivity">


    <ProgressBar
        android:id="@+id/progress_horizontal"
        style="@style/Widget.AppCompat.ProgressBar.Horizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:max="10" />

    <com.google.android.material.button.MaterialButton
        android:id="@+id/btn"
        android:layout_width="160dp"
        android:layout_height="wrap_content"
        android:layout_marginTop="100dp"
        android:background="#1E1C1C"
        app:elevation="20dp"
        android:backgroundTint="#1E1C1C"
        android:text="Start"
        android:textColor="@android:color/white"
        app:cornerRadius="20dp" />


</LinearLayout>



As you can see in above MainActivity.xml, doInBackground() method run the task on the background thread and we are passing the data from the background thread to the main thread (“UI Thread”) with help of publishProgress() method and this method invoke the onProgressUpdate() where we get the result from the background the thread.

I know, you are thinking that why I am showing you the basic things about AsyncTask basically I am just trying you to go through the basics of AsyncTask, it helps if some newbies come here and you also.

Let’s jump to questions related to AsyncTask one-by-one.

1. Which method runs in the background thread and which on the main thread?

Ans: Only doInBackground() method is run on the background thread and all other methods of the AsyncTask run on the main thread.


2. What if we call AsyncTask’s execute method multiple times?

Ans: So here are two scenarios:-
a)- if we call the asynctask.execute() method multiple time on the same instance then we got runtime-exception as it is due to when AsyncTasks introduced first starting from DONUT were executed serially on a single background thread but onwards HONEY_COMB they introduced a new method executeOnExecutor() where you can use a thread pool to perform multiple tasks parallelly, we will see it later in this article, don’t worry.

b)- In the second scenario, if we call execute method multiple time but every time we are creating a new object of the async task such as MyAsynctask().execute() then we won’t get any exception but all tasks perform serially.


3. When we call execute method multiple times then how do all tasks perform synchronously or asynchronously?

Ans: When we call execute method multiple times (but remember we have to create a new instance of AsyncTasks every time we call execute method as discussed in the previous question)  then all tasks perform one-by-one means synchronously.


4. Can we perform multiple tasks asynchronously in AsyncTask, if yes then how?

Ans: Yes, by default the async task uses a single thread but we can do this using multiple threads with the help of THREAD_POOL_EXECUTOR. In AsyncTasks we have two methods to execute AsyncTasks one is execute() and other is executeOnExecutor().
So with this second method, we can perform multiple tasks asynchronously and it takes two params one is AsyncTasks input and other is a thread pool object where we define no of thread, so it is better to learn by doing.
Let’s do some code


button.setOnClickListener {

   MAsyncTask(10).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);

}


5. What is memory leaks, when it happened in the AsyncTask and how you can handle this?

Ans: a) Memory leaks:- To understand memory leaks we have to understand what is the garbage collector first.

Garbage Collector: Every time when you create an object its reference is stored in the stack or we can say object created in the stack and stored in heap. This reference in the stack pointing to its’ heap object we called it a pointer.

When we run the program all referencing object releases from the stack memory as they execute one-by-one and free-up the stack memory.

But what about the objects in the heap memory so here is our man the garbage collector comes in the picture, it looks-up in the heap memory if any object which has not any reference pointing to it then garbage collector releases it and free-up the heap memory.

Now you have a clear picture of the duty of the garbage collector to release the unused object from the heap memory.

What is memory leaks: when garbage collector failed to release the unused object that means when some objects in the memory are unused in the application but they have their references pointing to them so garbage collector feels that they are still using somewhere in the application but in reality, they are not using any more and garbage collector does not release them and these objects are still occupying the memory at the end of the application this lead to memory leaks.

Ans: b) Memory leaks in AsyncTask: As you can see in the above code snippet, we are calling AsyncTask from a button, so we click the button task start and updates our progress bar but if the user rotates the screen or press back button then activity gets destroyed and AsyncTask continues running in the background and AsyncTask holds the reference of our activity context which means object does not get garbage collected and leads to a memory leak.

android-readerlook
LeakCanary

As you can see in the above screenshot that we are getting memory leaks. There is a library which helps us to easily detect memory leak where you’ll see the exact same kind of screen when you get any memory leak in your application and you just need to put the leak canary dependency in the build.gradle and you will automatically notify if any memory leaks happened in the application.


dependencies {
  // debugImplementation because LeakCanary should only run in debug builds.
  debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.4'
}



LeakCanary: https://square.github.io/leakcanary/getting_started/   for the full documentation.

Ans: c) Here is the good news for you developers that AsyncTask is deprecated in Android API level 30, but there are lots of different question has been asked recently on AsyncTask.
Check this official link: https://developer.android.com/reference/android/os/AsyncTask.

Let’s come to the point that how we can avoid memory leaks in Asynctask so there are multiple approaches to avoid memory leak but all depends on which purpose you are going to use AsyncTask. Two simple and best approaches I am going to show you which are mostly used to handling the memory leaks.

-> Using WeakReference: The weak reference does not protect the object from Garbage collection and the activity object easily garbage collected, let’s jump to the code.


private  class MAsyncTask(mainActivity: MainActivity) : AsyncTask<Void, Int, Void>() {

   private var mainActivity: WeakReference<MainActivity>? = null

   init {
       this.mainActivity = WeakReference(mainActivity)
   }

   override fun doInBackground(vararg p0: Void?): Void? {

       for (i in 0..10) {
           SystemClock.sleep(1000)
           onProgressUpdate(i)
       }
       return null
   }

   override fun onProgressUpdate(vararg values: Int?) {
       if (mainActivity!!.get() != null) {
           //adapt contents
           mainActivity!!.get()!!.mProgressBar.progress = values[0]!!

       }

   }

}



As you can see we are getting the activity object through the weak reference and when any config changes or if the user pressed back button then this activity weak reference object easily finalize or garbage collected because it does not protect the activity object from the garbage collector and there are no memory leaks in the end.

 -> Second approach by cancelling the AsyncTask:  Let’s check proper way to cancel the AsyncTask to avoid memory leaks. In doInBackground()  check if isCancelled() method is return true then break the loop or return otherwise continue the task and in onStop() method call mAsyncTask.cancel(true). Let’s check this in the code.

      
override fun doInBackground(vararg p0: Void?): Void? {
            
            for (i in 0..10) {
                if (isCancelled()) {
                    break;
                }
                SystemClock.sleep(1000)


                onProgressUpdate(i)
            }
            return null
        }

 override onStop(){
  if(mAsyncTask!=null)
    mAsyncTask.canel(true)
}



As you have seen I have shown you two types of approach but there more types of approach and I suggest to check this article learn more types of approaches to handle memory leaks in Android not only in AsyncTask click here




Happy Coding

As I already told you that AsyncTask has been deprecated since Android API level 30, but in the case of interview lots of question asked by the interviewer to check the candidate’s understanding in the multi-threading concepts, so please read all the questions properly they’ll definitely help you in your Android interviews. And if someone has more questions related to AsyncTask please comment them below we will consider them in our coming article based on Android Interview Questions.
Hope you enjoyed this article please share your love by commenting below and subscribe our newsletter for future article’s notification.

Related posts
Technology

In-App Review Android

2 Mins read
We are waiting & hoping this for a long time and finally, the Android team released it on August 05 2020. Google-Android…
0 0 vote
Article Rating
0 Comments
Inline Feedbacks
View all comments