14.3.2. Using the Runnable Interface

To create a thread using the Runnable interface, you define a class that implements the Runnable interface and override its run() method.

In Java, the Runnable interface is a functional interface that needs to be implemented to represent a block of code that can be executed by a thread. By defining a class that implements this interface, you will override its run() method, which contains the code that will be executed when the thread starts. This is a flexible way to create threads, as it allows your class to extend another class if needed, since Java only allows single inheritance.

Think of the Runnable interface like a blueprint for a task. If you want to build a house (the thread), you can't just directly start building. Instead, you must create a plan (your class implementing Runnable) that describes how the house should be constructed (the code in run()). This allows you to build multiple houses without worrying about the details of the construction process every time.

After defining your Runnable class, you create a Thread object by passing an instance of your class to the Thread constructor. Finally, you call the start() method to begin execution.

Once your Runnable class is created, you instantiate it and wrap it in a Thread object. This is done by creating a new Thread and passing the instance of your Runnable class as an argument. The start() method is then called on the Thread object, which tells the Java Virtual Machine (JVM) to run the code in the run() method of your Runnable class in a new thread. This separates its execution from the main thread of your application.

Imagine you're hosting an event and have a team of people (threads) that each have specific tasks to complete (Runnable classes). You give each person a task description (Runnable instance) and tell them to start (by calling start()). They begin working on their tasks independently, while you continue managing the overall event (the main thread).

Here is a brief example of how to implement the Runnable interface:

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

In the provided code example, a class named MyRunnable is created which implements the Runnable interface. The run() method is overridden to define the task the thread will execute, which in this case, is simply printing a message to the console. A new Thread object is then instantiated, passing a new instance of MyRunnable to the constructor. Calling the start() method on t2 invokes the run() method in a new thread of execution.

Consider this code as a job assignment sheet. The MyRunnable class describes the job (what needs to be done), while the run() method is like the specific instructions on the job sheet. Once you fill out the job sheet and hand it to an employee (the Thread), they can begin working on the task independently.

--