Runnable Interface in Java
The Runnable interface is one of the simplest and most important building blocks of Java multithreading. It represents a task that can be executed, while a Thread provides a mechanism for executing that task concurrently.
This distinction may look small, but it leads to an important design principle: separate the work from the worker. Once you understand that idea, Runnable becomes much easier to use and its role in larger concurrency APIs becomes clearer.
What Is the Runnable Interface?
Runnable is a functional interface from the java.lang package. It represents an operation that can be executed without returning a result.
@FunctionalInterface
public interface Runnable {
void run();
}
The interface contains a single abstract method named run(). Because it has only one abstract method, Runnable can be implemented using a lambda expression or method reference.
Remember: Runnable describes what work should be performed. It does not itself create or start a thread.
Why Does Runnable Exist?
Imagine a restaurant. A customer places an order, the kitchen prepares the food, and a chef performs the actual work. The order represents what needs to be done, while the chef represents who performs it.
Runnable follows a similar idea. The Runnable object represents the task, while the Thread can execute that task.
Runnable task = () -> {
System.out.println("Processing order");
};
Thread worker = new Thread(task);
worker.start();
Here, the lambda defines the task. The Thread object is responsible for executing that task on a separate thread.
Implementing Runnable
The traditional approach is to create a class that implements Runnable and provide the implementation of run().
class FileProcessor implements Runnable {
@Override
public void run() {
System.out.println("Processing file...");
for (int i = 1; i <= 3; i++) {
System.out.println("Processing step " + i);
}
}
}
public class RunnableDemo {
public static void main(String[] args) {
FileProcessor task = new FileProcessor();
Thread thread = new Thread(task);
thread.start();
}
}
The FileProcessor class does not extend Thread. Instead, it simply describes the work that needs to be performed.
The Thread object receives that task through its constructor. Calling start() then begins a new thread, which eventually invokes the Runnable's run() method.
Runnable Does Not Start a Thread
A very common beginner mistake is assuming that implementing Runnable automatically creates a new thread.
Runnable task = () -> {
System.out.println(
Thread.currentThread().getName()
);
};
task.run();
The code above simply calls the run() method directly. It does not create a new thread.
To execute the task on a separate thread, the Runnable must be given to a Thread and the Thread must be started.
Runnable task = () -> {
System.out.println(
Thread.currentThread().getName()
);
};
Thread thread = new Thread(task);
thread.start();
Critical distinction: Calling run() directly performs the task on the current thread. Calling start() on the Thread creates a separate execution path for the task.
Runnable with a Lambda Expression
Since Runnable is a functional interface, Java allows us to replace a verbose anonymous implementation with a lambda expression.
Runnable task = () -> {
System.out.println("Task is running");
};
Thread thread = new Thread(task);
thread.start();
This is often easier to read when the task is small and its logic is local to the place where the Thread is created.
Passing Runnable Directly to Thread
When a Runnable is needed only once, there is no requirement to store it in a separate variable.
Thread thread = new Thread(() -> {
System.out.println("Background task started");
});
thread.start();
This compact style is common in simple examples and small application-level tasks.
Runnable with Parameters
The run() method itself does not accept parameters. However, the task can access values captured from its surrounding scope.
public class RunnableParameterExample {
public static void main(String[] args) {
String fileName = "report.pdf";
Runnable task = () -> {
System.out.println(
"Processing: " + fileName
);
};
Thread thread = new Thread(task);
thread.start();
}
}
The lambda captures the local variable fileName. Local variables captured by a lambda must be final or effectively final.
Runnable and Shared Objects
Multiple threads can execute the same type of Runnable task, and those tasks may interact with shared objects.
class CounterTask implements Runnable {
private int counter = 0;
@Override
public void run() {
for (int i = 1; i <= 5; i++) {
counter++;
}
System.out.println(
"Counter: " + counter
);
}
}
This example is simple, but shared mutable state becomes much more interesting when multiple threads access the same object. If several threads modify shared data concurrently, the program may require synchronization or another thread-safe design.
That is why Runnable should not be viewed only as a way to shorten thread creation. It is also an important part of designing tasks that can be managed independently from their execution mechanism.
Runnable vs Extending Thread
| Runnable | Extending Thread |
|---|---|
| Represents a task. | Represents a thread. |
| Does not create a thread by itself. | Provides Thread behavior directly. |
| Allows the class to extend another class. | Uses the class's single inheritance relationship for Thread. |
| Separates task logic from thread management. | Combines task logic with the Thread subclass. |
| Works naturally with lambda expressions. | Requires a Thread subclass when using this approach. |
Why Runnable Is Usually a Better Design
The biggest advantage of Runnable is not that it is shorter. Its real strength is separation of responsibilities.
A class that represents a business task should not necessarily need to become a Thread. By keeping the task independent, the same Runnable can potentially be executed by different concurrency mechanisms.
class ReportTask implements Runnable {
@Override
public void run() {
System.out.println("Generating report");
}
}
public class RunnableDesign {
public static void main(String[] args) {
Runnable task = new ReportTask();
Thread thread = new Thread(task);
thread.start();
}
}
The task knows how to generate the report. It does not need to know whether a raw Thread, an executor, or another concurrency mechanism will eventually execute it.
Architecture insight: Separating a task from its execution mechanism is a recurring design principle in software engineering. Runnable is one of Java's simplest examples of this separation.
Runnable Has No Return Value
The run() method returns void. Therefore, Runnable is appropriate when the task does not directly return a result to its caller.
Runnable task = () -> {
System.out.println("Task completed");
};
new Thread(task).start();
If a concurrent computation needs to produce a result, Java provides other abstractions, such as Callable together with future-based concurrency mechanisms.
Runnable Cannot Directly Throw Checked Exceptions
The Runnable run() method does not declare checked exceptions. Therefore, a Runnable implementation cannot simply add a checked exception to its method signature.
class FileTask implements Runnable {
@Override
public void run() {
// A checked exception cannot simply
// be declared here by changing run().
System.out.println("Reading file");
}
}
When a task performs an operation that throws a checked exception, the exception generally needs to be handled inside the task or converted into an appropriate unchecked exception, depending on the application's design.
Common Beginner Mistakes
- Thinking that implementing Runnable automatically starts a thread.
- Calling run() directly when concurrent execution is required.
- Confusing Runnable with Thread.
- Putting large amounts of unrelated business logic into an anonymous Runnable.
- Ignoring shared mutable state when several Runnable tasks access the same object.
- Expecting Runnable's run() method to return a computed value.
Best Practices
- Use Runnable to represent independent units of work.
- Prefer lambda expressions for small, straightforward tasks.
- Keep larger tasks in named classes when that improves readability and testing.
- Keep task logic independent from thread-management logic whenever practical.
- Use appropriate concurrency utilities when tasks need results, cancellation, scheduling, or controlled execution.
- Protect shared mutable state when multiple threads can access it concurrently.
Interview Insights
Question: What is Runnable in Java?
Runnable is a functional interface that represents a task whose run() method can be executed. It does not itself create a thread.
Question: Does Runnable create a new thread?
No. Runnable represents the task. A Thread or another concurrency mechanism must execute that task.
Question: Why prefer Runnable over extending Thread?
Runnable separates the task from the thread and preserves the class's ability to extend another class. It also fits naturally with lambda expressions and higher-level concurrency mechanisms.
Question: Can Runnable return a value?
Not directly. Its run() method returns void. A result-producing concurrent task is better represented by abstractions such as Callable.
Quick Revision
| Concept | Key Point |
|---|---|
| Runnable | A functional interface representing a task that can be executed. |
| run() | The method containing the task's executable logic. |
| Thread | Can execute a Runnable task on a separate thread. |
| start() | Starts a new thread and allows the Runnable task to execute there. |
| Direct run() | Executes on the current thread and does not create a new thread. |
| Lambda | Provides a concise implementation of Runnable. |
| Return value | Runnable's run() method returns void. |
| Main advantage | Separates task logic from the mechanism used to execute the task. |
The most useful mental model is simple: Runnable is the work, Thread is one way to run that work. This separation makes code easier to reason about and prepares you for the higher-level concurrency mechanisms used in professional Java applications. With Runnable understood, the next step is to see what actually happens to a thread from creation through termination—the Thread Lifecycle.