What are the ways to create a thread in Android?

In Android, you can create threads in the following ways:

• Inheriting from Thread:

  // Class inheriting from Thread
  class MyThread extends Thread {
      @Override
      public void run() {
          // Code of the task executed in the new thread
          System.out.println("Thread created by inheriting from Thread");
      }
  }
  // Creating and starting the thread
  MyThread myThread = new MyThread();
  myThread.start();
  

• Implementing the Runnable interface:

  // Class implementing Runnable
  class MyRunnable implements Runnable {
      @Override
      public void run() {
          // Code of the task executed in the new thread
          System.out.println("Thread created by implementing Runnable");
      }
  }
  // Creating a thread with Runnable
  Thread thread = new Thread(new MyRunnable());
  thread.start();
  

• Using AsyncTask (deprecated): for executing operations in the background thread and updating UI.

• Using HandlerThread: a special class of Thread with Looper and Handler, simplifying message queue handling in a background thread.

  // Creating HandlerThread
  HandlerThread handlerThread = new HandlerThread("MyHandlerThread");
  handlerThread.start();
  // Getting Looper
  Looper looper = handlerThread.getLooper();
  // Creating Handler attached to Looper
  Handler handler = new Handler(looper);
  // Sending a task to the thread's queue
  handler.post(new Runnable() {
      @Override
      public void run() {
          // Code of the task executed in handlerThread
          System.out.println("Thread created using HandlerThread");
      }
  });
  

• Using ExecutorService and ThreadPoolExecutor: for managing a thread pool.

  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  
  // Creating a thread pool with a fixed size
  ExecutorService executor = Executors.newFixedThreadPool(2);
  // Submitting a task to the thread pool
  executor.execute(new Runnable() {
      @Override
      public void run() {
          // Code of the task executed in one of the pool's threads
          System.out.println("Thread created using ExecutorService");
      }
  });
  // Shutting down the pool (important to prevent leaks)
  executor.shutdown();
  

• Using Kotlin coroutines: a modern approach for asynchronous programming in Android.

  import kotlinx.coroutines.*
  
  // Launching a coroutine in the background thread
  GlobalScope.launch(Dispatchers.IO) {
      // Code of the task executed in the background (IO) thread
      println("Thread created using coroutines")
  }