Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Complete guide to the Runnable interface in Java — functional interface, lambda usage, Callable vs Runnable, task encapsulation, sharing Runnables, and modern patterns with ExecutorService.
What is the Runnable Interface?
Runnable is a functional interface in java.lang package with a single abstract method run(). It represents a task that can be executed by a thread.
java example
@FunctionalInterface
public interface Runnable {
void run();
}Why Runnable is Preferred Over Extending Thread
- Single inheritance: Your class can still extend another class
- Separation of concerns: Task logic is separate from threading
- Reusability: Same Runnable can be used with Thread, ExecutorService, etc.
- Composition: Multiple tasks can be composed together
- Testability: Easy to test without running in a separate thread
Basic Runnable Implementation
Example
// Traditional class implementation
class PrintTask implements Runnable {
private String message;
private int times;
public PrintTask(String message, int times) {
this.message = message;
this.times = times;
}
@Override
public void run() {
for (int i = 1; i <= times; i++) {
System.out.printf("[%s] %s (%d/%d)%n",
Thread.currentThread().getName(), message, i, times);
try { Thread.sleep(200); } catch (InterruptedException e) { return; }
}
}
}
public class RunnableBasic {
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Runnable Interface Basic ===\n");
// Create tasks (independent of threading)
Runnable task1 = new PrintTask("Downloading", 3);
Runnable task2 = new PrintTask("Uploading", 3);
// Execute in threads
Thread t1 = new Thread(task1, "DL-Thread");
Thread t2 = new Thread(task2, "UL-Thread");
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("\n--- Same task, different execution ---");
// Same Runnable executed directly (no new thread)
System.out.println("Running on main thread:");
Runnable task3 = new PrintTask("Testing", 2);
task3.run(); // Just a method call — no new thread!
System.out.println("Done!");
}
}
Output
=== Runnable Interface Basic === [Thread-0] Download (1/5) [Thread-1] Upload (1/5) [Thread-0] Download (2/5) [Thread-1] Upload (2/5) [Thread-0] Download (3/5) [Thread-1] Upload (3/5) [Thread-0] Download (4/5) [Thread-1] Upload (4/5) [Thread-0] Download (5/5) [Thread-1] Upload (5/5) All tasks complete!
Runnable with Lambda Expressions
Since Runnable is a functional interface, lambdas make it concise:
Example
public class RunnableLambda {
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Runnable with Lambdas ===\n");
// Full lambda
Runnable task1 = () -> {
String name = Thread.currentThread().getName();
for (int i = 0; i < 3; i++) {
System.out.println("[" + name + "] Working... " + i);
try { Thread.sleep(100); } catch (InterruptedException e) { return; }
}
};
// Short lambda
Runnable task2 = () -> System.out.println("Quick task on: " + Thread.currentThread().getName());
// Method reference
Runnable task3 = RunnableLambda::heavyComputation;
// Directly in Thread constructor
Thread t1 = new Thread(() -> {
System.out.println("Inline lambda thread: " + Thread.currentThread().getName());
}, "InlineThread");
// Execute all
new Thread(task1, "Lambda-1").start();
new Thread(task2, "Lambda-2").start();
new Thread(task3, "Lambda-3").start();
t1.start();
Thread.sleep(500);
System.out.println("\nAll tasks launched!");
}
static void heavyComputation() {
System.out.println("[" + Thread.currentThread().getName() + "] Computing pi...");
double pi = 0;
for (int i = 0; i < 1_000_000; i++) {
pi += Math.pow(-1, i) / (2 * i + 1);
}
pi *= 4;
System.out.printf("[%s] Pi ≈ %.10f%n", Thread.currentThread().getName(), pi);
}
}
Output
=== Runnable with Lambdas === [Task-A] Working... 1 [Task-B] Working... 1 [Task-A] Working... 2 [Task-B] Working... 2 [Task-A] Working... 3 [Task-B] Working... 3 All lambda tasks done!
Runnable vs Callable
Java 5 introduced Callable<V> — a Runnable that can return a value and throw exceptions:
Example
import java.util.concurrent.*;
public class RunnableVsCallable {
public static void main(String[] args) throws Exception {
System.out.println("=== Runnable vs Callable ===\n");
// Runnable: no return value, no checked exceptions
Runnable runnable = () -> {
System.out.println("Runnable: void return, no checked exceptions");
// Cannot return a value!
// Cannot throw checked exceptions!
};
// Callable: returns value, can throw exceptions
Callable<Integer> callable = () -> {
System.out.println("Callable: computing...");
Thread.sleep(500);
return 42; // Can return a value!
};
// Using ExecutorService
ExecutorService executor = Executors.newFixedThreadPool(2);
// Submit Runnable (get Future<?> with null result)
Future<?> future1 = executor.submit(runnable);
future1.get(); // Blocks, returns null
// Submit Callable (get Future<V> with actual result)
Future<Integer> future2 = executor.submit(callable);
Integer result = future2.get(); // Blocks, returns 42
System.out.println("Callable result: " + result);
executor.shutdown();
System.out.println("\n--- Comparison ---");
System.out.println("┌─────────────┬──────────────────┬───────────────────┐");
System.out.println("│ Feature │ Runnable │ Callable<V> │");
System.out.println("├─────────────┼──────────────────┼───────────────────┤");
System.out.println("│ Method │ void run() │ V call() │");
System.out.println("│ Return │ None (void) │ Generic type V │");
System.out.println("│ Exceptions │ No checked exc. │ throws Exception │");
System.out.println("│ Since │ Java 1.0 │ Java 5 │");
System.out.println("│ Used with │ Thread, Executor │ ExecutorService │");
System.out.println("│ Lambda │ () -> { ... } │ () -> { return; } │");
System.out.println("└─────────────┴──────────────────┴───────────────────┘");
}
}
Output
=== Runnable vs Callable === Runnable: void return, no checked exceptions Callable result: 120 (can return values!) Callable can throw checked exceptions.
Composing Runnables
java example
public class RunnableComposition {
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Composing Runnables ===\n");
// Individual tasks
Runnable validate = () -> System.out.println(" 1. Validating input...");
Runnable process = () -> System.out.println(" 2. Processing data...");
Runnable save = () -> System.out.println(" 3. Saving results...");
Runnable notify = () -> System.out.println(" 4. Sending notification...");
// Compose into a pipeline
Runnable pipeline = compose(validate, process, save, notify);
System.out.println("Running pipeline on new thread:");
Thread t = new Thread(pipeline, "Pipeline");
t.start();
t.join();
System.out.println("\nRunning pipeline on main thread:");
pipeline.run();
}
// Utility: compose multiple Runnables into one
static Runnable compose(Runnable... tasks) {
return () -> {
for (Runnable task : tasks) {
task.run();
}
};
}
}Output:
Example
=== Composing Runnables ===
Running pipeline on new thread:
1. Validating input...
2. Processing data...
3. Saving results...
4. Sending notification...
Running pipeline on main thread:
1. Validating input...
2. Processing data...
3. Saving results...
4. Sending notification...
Real-World Example: Task Queue
Example
import java.util.concurrent.*;
import java.util.*;
public class TaskQueue {
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Task Queue with Runnables ===\n");
// Queue of tasks
BlockingQueue<Runnable> taskQueue = new LinkedBlockingQueue<>();
// Add tasks to queue
taskQueue.add(createTask("Send email to user@example.com"));
taskQueue.add(createTask("Generate PDF report"));
taskQueue.add(createTask("Resize uploaded image"));
taskQueue.add(createTask("Update search index"));
taskQueue.add(createTask("Clear expired cache"));
System.out.println("Tasks queued: " + taskQueue.size());
System.out.println("Processing with 2 worker threads...\n");
// Worker threads process tasks
Thread worker1 = new Thread(createWorker(taskQueue), "Worker-1");
Thread worker2 = new Thread(createWorker(taskQueue), "Worker-2");
worker1.start();
worker2.start();
// Wait until queue is empty
while (!taskQueue.isEmpty()) {
Thread.sleep(100);
}
Thread.sleep(500); // Let last tasks finish
worker1.interrupt();
worker2.interrupt();
worker1.join();
worker2.join();
System.out.println("\nAll tasks processed!");
}
static Runnable createTask(String description) {
return () -> {
String worker = Thread.currentThread().getName();
System.out.printf(" [%s] Processing: %s%n", worker, description);
try { Thread.sleep(300 + (int)(Math.random() * 200)); }
catch (InterruptedException e) { Thread.currentThread().interrupt(); }
System.out.printf(" [%s] ✓ Done: %s%n", worker, description);
};
}
static Runnable createWorker(BlockingQueue<Runnable> queue) {
return () -> {
while (!Thread.currentThread().isInterrupted()) {
try {
Runnable task = queue.poll(100, TimeUnit.MILLISECONDS);
if (task != null) {
task.run();
}
} catch (InterruptedException e) {
break;
}
}
};
}
}
Output
=== Task Queue with Runnables === Tasks queued: 5 [pool-1-thread-1] Executing Task-1 [pool-1-thread-2] Executing Task-2 [pool-1-thread-1] Executing Task-3 [pool-1-thread-2] Executing Task-4 [pool-1-thread-1] Executing Task-5 All tasks processed!
Common Mistakes
1. Confusing Runnable execution
java example
Runnable task = () -> System.out.println("Thread: " + Thread.currentThread().getName());
// ❌ This does NOT create a new thread
task.run(); // Runs on current thread
// ✅ This creates a new thread
new Thread(task).start();2. Modifying shared state without synchronization
Example
// ❌ UNSAFE: Race condition
class Counter implements Runnable {
int count = 0; // Shared mutable state!
public void run() {
for (int i = 0; i < 1000; i++) count++;
}
}
// ✅ SAFE: Use atomic or synchronized
class SafeCounter implements Runnable {
java.util.concurrent.atomic.AtomicInteger count = new java.util.concurrent.atomic.AtomicInteger(0);
public void run() {
for (int i = 0; i < 1000; i++) count.incrementAndGet();
}
}
Interview Questions
Q1: What is the Runnable interface?
Answer: Runnable is a functional interface in java.lang with a single method void run(). It represents a task to be executed by a thread. Since Java 8, it can be implemented using lambda expressions.
Q2: Why is Runnable preferred over extending Thread?
Answer: (1) Allows extending another class (Java lacks multiple inheritance), (2) separates task logic from thread management, (3) same Runnable works with Thread, ExecutorService, ForkJoinPool, (4) promotes composition and reusability, (5) easier to test.
Q3: What is the difference between Runnable and Callable?
Answer: Runnable's run() returns void and cannot throw checked exceptions. Callable's call() returns a generic type V and can throw Exception. Callable is used with ExecutorService to get Future objects containing results.
Q4: Can a Runnable be reused across multiple threads?
Answer: Yes! A single Runnable instance can be passed to multiple Thread constructors. Each thread will execute the same run() method independently. However, if the Runnable has mutable state, proper synchronization is needed.
Q5: Is Runnable a functional interface?
Answer: Yes. It has exactly one abstract method (run()), making it usable with lambda expressions and method references since Java 8. Example: Runnable r = () -> System.out.println("Hello");
Q6: Why is Runnable a functional interface?
A: Runnable has exactly one abstract method (run()), making it a functional interface annotated with @FunctionalInterface. This means it can be implemented using lambda expressions or method references in Java 8+: new Thread(() -> doWork()).start(). This dramatically reduces boilerplate for simple thread tasks.
Q7: Can a single Runnable instance be shared among multiple threads?
A: Yes! Unlike extending Thread (where each instance IS a thread), a single Runnable can be passed to multiple Thread constructors. All threads execute the same run() method. This is useful for tasks that share resources, but requires synchronization if the Runnable has mutable state.
Q8: How does Runnable work with ExecutorService?
A: ExecutorService accepts Runnable tasks via execute(Runnable) or submit(Runnable). The executor manages a thread pool — your Runnable runs on a pooled thread instead of creating new threads. submit() returns a Future<?> for tracking completion (though Runnable doesn't return a value).
Q9: What is the difference between Runnable and Callable?
A: Runnable: void run() — no return value, cannot throw checked exceptions. Callable: V call() throws Exception — returns a value of type V, can throw checked exceptions. Use Callable when you need to get a result back from the thread (via Future.get()).
Q10: How do you convert a Runnable to a Callable?
A: Use Executors.callable(runnable) which returns a Callable that returns null. Or Executors.callable(runnable, result) which returns a specified result. You can also wrap manually: () -> { runnable.run(); return result; }.
Q11: Is Runnable's run() method thread-safe?
A: The run() method itself has no built-in thread safety. If the Runnable accesses shared mutable state, YOU must provide synchronization (synchronized blocks, volatile, Atomic classes, etc.). Runnable is just a task definition — thread safety is the developer's responsibility.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Runnable Interface in Java.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, multithreading, runnable, interface
Related Java Master Course Topics
Continue learning this concept
MultithreadingCreating Threads in JavaComplete guide to creating threads in Java — extending Thread class, implementing Runnable interface, lambda expressions, comparison of approaches, and when to use each method.MultithreadingDaemon Threads in JavaComplete guide to Daemon Threads in Java — what they are, how they differ from user threads, JVM shutdown behavior, practical use cases like GC and auto-save, and common pitfalls.MultithreadingExecutor Framework in JavaComplete guide to the Executor Framework in Java — ExecutorService, thread pools, Future, Callable, ScheduledExecutorService, and modern concurrent programming patterns.MultithreadingInter-Thread Communication in JavaComplete guide to Inter-Thread Communication in Java — wait(), notify(), notifyAll(), producer-consumer pattern, and how threads coordinate using object monitors.MultithreadingMultithreading Programs in JavaCollection of practical multithreading programs in Java — producer-consumer, dining philosophers, reader-writer, parallel merge sort, web crawler, and other classic concurrent programming exercises.MultithreadingSynchronization in JavaComplete guide to Synchronization in Java — race conditions, synchronized methods and blocks, intrinsic locks, volatile keyword, atomic variables, and deadlock prevention.