1.1.2. Creating Threads in Java

There are two primary ways to create threads in Java:

1. Extending the Thread class
2. Implementing the Runnable interface

Java provides two main approaches for creating threads. The first method is by extending the Thread class. When you extend this class, you override the run() method, which contains the code that defines what the thread will do when started. The second method is to implement the Runnable interface. This approach is more flexible since it allows a class to extend from another class while still using threading capabilities. You also implement the run() method in this case.

Think of creating a thread as choosing between two ways to start a new task. You could either adopt a specific toolkit (extending the Thread class) that dictates how tasks are done or use a blueprint (implementing the Runnable interface) that allows you to customize your own tools while still ensuring the tasks are completed.

class MyThread extends Thread {
   public void run() {
      System.out.println("Thread is running.");
   }
}

public class Test {
   public static void main(String[] args) {
      MyThread t1 = new MyThread();
      t1.start(); // starts a new thread
   }
}

In this chunk, we see how to create a thread by extending the Thread class. We define a new class MyThread that inherits from Thread and override the run() method to specify what the thread should do. In the main method of the Test class, we create an instance of MyThread and call t1.start(), which tells the JVM to execute the run() method on a new thread, allowing our message "Thread is running." to be printed to the console.

Imagine you are a chef who decides to make a special dish. By extending the Thread class, you create a specific recipe that outlines the exact steps (in the run() method) for making that dish. When you start cooking (invoking start()), the recipe comes to life, and you can follow the steps to complete your meal.

class MyRunnable implements Runnable {
   public void run() {
      System.out.println("Runnable thread is running.");
   }
}

public class Test {
   public static void main(String[] args) {
      Thread t1 = new Thread(new MyRunnable());
      t1.start();
   }
}

Here, we create a thread by implementing the Runnable interface. We define a class MyRunnable that implements Runnable and again override the run() method. In the main method, we create a new Thread, passing in an instance of MyRunnable. When t1.start() is called, it executes the run() method on a new thread as before, printing the message "Runnable thread is running." to the console. This method of creating threads is generally preferred for its flexibility.

Consider this method as hiring a subcontractor (implementing Runnable) to perform a task while you manage the overall project. You define what you need them to do in the run() method, and when you give the green light (calling start()), they jump into action, completing their part of the project.

--