Ways to Create Threads in Java

Mttao included in category Java

2023-10-07 2023-10-07 1004 words 5 minutes

Contents

This article explores the ways to create threads in Java based on JDK 11. My answer is that there are only two ways: extending the Thread class and implementing the Runnable interface, as stated in the Oracle official documentation.

Thread Class

The Thread class is provided by Java to represent a thread. It is a concrete class that implements the Runnable interface and offers additional thread control and management functionalities. By extending the Thread class, you can create custom thread classes.

Runnable Interface

The Runnable interface is a functional interface defined by Java, used to represent tasks that can be executed. By implementing the Runnable interface, you can encapsulate the task logic in the run() method and pass it to a Thread object to create a thread.

Difference Between Thread and Runnable Implementations of the run Method

The Thread class itself implements the Runnable interface, while Runnable is just an interface. When you create and start a Thread, it opens a new thread and executes its run() method within this new thread. When you create a Runnable and pass it to the Thread constructor, the Thread will execute the run() method of the Runnable in the new thread.

Here is a code analysis showing the Thread class implementing the Runnable interface:

java

public class Thread implements Runnable {
    // ... other code omitted
    
    // Constructor accepting a Runnable instance
    public Thread(Runnable target) {
        this(null, target, "Thread-" + nextThreadNum(), 0);
    }
    
    public Thread(ThreadGroup group, Runnable target, String name, long stackSize) {
        this(group, target, name, stackSize, null, true);
    }
    
    private Thread(ThreadGroup g, Runnable target, String name, long stackSize, AccessControlContext acc, boolean inheritThreadLocals) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }
        // ... other code omitted
        // Assigning the Runnable instance to this.target field
        this.target = target;
        // ... other code omitted
    }
    
    @Override
    public void run() {
        // Key point: check if target is not null
        if (target != null) {
            target.run();
        }
    }
}

What happens if you both implement Runnable’s run method and override Thread’s run method?

Here’s the code:

java

public class ThreadDemo {
    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println("Runnable run");
        }) {
            @Override
            public void run() {
                System.out.println("Thread run");
            }
        }.start();
    }
}

Output:

shell

Thread run

Runnable Implementation is Preferable to Thread

In Java, while both Runnable and Thread can be used for implementing multi-threading, using the Runnable interface is generally considered better for several reasons:

Avoid Inheritance Limitation: Java is a single-inheritance language. If you extend the Thread class to create a thread, you cannot extend any other class. Using the Runnable interface avoids this limitation as Java allows a class to implement multiple interfaces.
Improved Code Organization: By separating the task logic from the thread logic, using a class that implements the Runnable interface can better modularize and organize the code. This enhances code readability, maintainability, and testability.
Greater Flexibility: The Runnable interface allows the task code to be shared across multiple threads, providing more flexibility in switching tasks between threads. Thread class-based threads have tightly coupled task and thread code, which is less flexible.
Resource Sharing and Thread Pool Usage: Runnable interfaces support better use of thread pools. A thread pool is a mechanism for reusing threads efficiently and managing their lifecycle. By submitting Runnable tasks to a thread pool, you can better manage resources and improve system performance.
Extendability and Replaceability: If you need to change the thread implementation method in the future, such as using the Executor framework or other concurrency tools, using the Runnable interface makes migration and replacement easier. Using the Thread class might require significant code changes.

Overall, using the Runnable interface to implement Java threads is preferable because it provides better code organization, maintainability, and extensibility while avoiding inheritance limitations and supporting resource sharing and thread pool usage.