Understanding Multi-threading in Android

manish choudhary

1 April 2019

Why create a separate thread?

The thread is a process which executes the sequence of instruction. In Android, if there is some task taking more than 5sec it will cause ANR (Application Not Responding) error. To avoid these cases we need to create a separate thread. In Android, there is UI thread which performs entire UI operation that’s mean we cannot perform any UI update on the background thread.

So how can we update UI from a Background thread?

Android introduce Asynctask for such cases we can update UI component in Asynctask and perform the long-running operation at the same time. In Asynctask there are 3 methods onPreExecute(), onBackground() and onPostExecute(). We can perform UI component related operation on onPostExecute() method.

How many threads we can create in Android?

There is no specific limit to create a thread in android we can create as many threads we need to perform background operations. But creating too many threads can cause deadlock if we are unable to manage them. Thread pool is a better approach instead of creating separate threads.

Let’s now discuss when we have to create a Thread, Asynctask, and ThreadPool in android to perform background task. In Android, there are many options to execute background operations.

Threads are simple to create and run until task done but there is problem is that we can’t perform UI related update from it and they died after there task done. There are two ways to create threads either extend Thread class or implement Runnable interface.

// Create Thread by extends Thread class
    class Task extends Thread {
        @Override
        public void run() {
      // Perform Long Running Task
            super.run();
        }
    }
// Create Thread by implement Runnable class
    class DownloadTask implements Runnable {

        @Override
        public void run() {
      // Perform Long Running Task      
        }
    }

// Create Thread by extends Thread class

class Task extends Thread {

@Override

public void run() {

// Perform Long Running Task

super.run();

}

// Create Thread by implement Runnable class

class DownloadTask implements Runnable {

@Override

public void run() {

// Perform Long Running Task

}

AsyncTask is good to perform background task and we can even update UI from AsyncTask. In AsyncTask there are 3 methods onPreExecute(), onBackground() and onPostExecute(). OnPreExecuate() method invoke before the onBackground() and we can show a progress bar or any other UI component from it. OnBackground() it is like the run() method in the thread which runs in a background thread so we can’t perform any UI related operation there. OnPostExecute() invoke when the task is done and we can update UI from there.

    class DownloadTask extends AsyncTask<String, Void, String> {

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
        }

        @Override
        protected String doInBackground(String... strings) {
            return null;
        }

        @Override
        protected void onPostExecute(String s) {
            super.onPostExecute(s);
        }
    }

class DownloadTask extends AsyncTask<String, Void, String> {

@Override

protected void onPreExecute() {

super.onPreExecute();

}

@Override

protected String doInBackground(String... strings) {

return null;

}

@Override

protected void onPostExecute(String s) {

super.onPostExecute(s);

}

ThreadPool is a better choice to run multiple tasks in the background. There are many libraries used ThreadPool like Glide, Picasso these libraries download the images in the background and update the image on UI using the handler.

var service = ThreadPoolExecutor(
                Runtime.getRuntime().availableProcessors(),/* Here we can get Device available Processors*/
                50,/* Defined Queue size*/
                1,/* Timeout in numberic */
                TimeUnit.SECONDS,/* Timeout unit */
                LinkedBlockingQueue<Runnable>()) /* Defined LinkedBlockingQueue of Runnable here */


 service?.execute(object : Runnable {
            override fun run() {
               // Perform Long running operation 
            }
        })

var service = ThreadPoolExecutor(

Runtime.getRuntime().availableProcessors(),/* Here we can get Device available Processors*/

50,/* Defined Queue size*/

1,/* Timeout in numberic */

TimeUnit.SECONDS,/* Timeout unit */

LinkedBlockingQueue<Runnable>()) /* Defined LinkedBlockingQueue of Runnable here */

service?.execute(object : Runnable {

override fun run() {

// Perform Long running operation

}

})

I hope you have got some idea where to use Threads, AsynckTask and ThreadPool.