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 creating threads in Java — extending Thread class, implementing Runnable interface, lambda expressions, comparison of approaches, and when to use each method.
Two Ways to Create Threads
Java provides two fundamental approaches to create threads:
- Extending the
Threadclass - Implementing the
Runnableinterface
Both achieve the same goal but differ in flexibility and design philosophy.
Method 1: Extending the Thread Class
Example
// Step 1: Create a class that extends Thread
class MyThread extends Thread {
private String taskName;
public MyThread(String taskName) {
this.taskName = taskName;
}
// Step 2: Override the run() method
@Override
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.printf("[%s] Step %d (Thread: %s)%n",
taskName, i, Thread.currentThread().getName());
try {
Thread.sleep(300);
} catch (InterruptedException e) {
System.out.println(taskName + " was interrupted!");
return;
}
}
System.out.println("[" + taskName + "] Completed!");
}
}
public class ThreadExtendExample {
public static void main(String[] args) {
System.out.println("=== Creating Thread by Extending Thread ===\n");
// Step 3: Create instances and start
MyThread t1 = new MyThread("Download");
MyThread t2 = new MyThread("Upload");
t1.setName("Downloader");
t2.setName("Uploader");
// start() creates new thread and calls run()
t1.start();
t2.start();
// Main thread work
System.out.println("[Main] Both threads started. Main continues...");
// Wait for both to complete
try {
t1.join();
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("\n[Main] All threads finished!");
}
}
Output (interleaved):
| [Download] Step 1 (Thread | Downloader) |
| [Upload] Step 1 (Thread | Uploader) |
| [Download] Step 2 (Thread | Downloader) |
| [Upload] Step 2 (Thread | Uploader) |
| [Download] Step 3 (Thread | Downloader) |
| [Upload] Step 3 (Thread | Uploader) |
| [Download] Step 4 (Thread | Downloader) |
| [Upload] Step 4 (Thread | Uploader) |
| [Download] Step 5 (Thread | Downloader) |
| [Upload] Step 5 (Thread | Uploader) |
Method 2: Implementing the Runnable Interface
Example
// Step 1: Create a class that implements Runnable
class FileProcessor implements Runnable {
private String filename;
public FileProcessor(String filename) {
this.filename = filename;
}
// Step 2: Implement the run() method
@Override
public void run() {
System.out.printf("[%s] Processing started on %s%n",
Thread.currentThread().getName(), filename);
for (int i = 0; i <= 100; i += 20) {
System.out.printf("[%s] %s: %d%% complete%n",
Thread.currentThread().getName(), filename, i);
try {
Thread.sleep(200);
} catch (InterruptedException e) {
return;
}
}
System.out.printf("[%s] %s: DONE!%n", Thread.currentThread().getName(), filename);
}
}
public class RunnableExample {
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Creating Thread with Runnable ===\n");
// Step 3: Create Runnable instances
Runnable task1 = new FileProcessor("report.pdf");
Runnable task2 = new FileProcessor("data.csv");
Runnable task3 = new FileProcessor("image.png");
// Step 4: Pass to Thread constructor and start
Thread t1 = new Thread(task1, "Worker-1");
Thread t2 = new Thread(task2, "Worker-2");
Thread t3 = new Thread(task3, "Worker-3");
t1.start();
t2.start();
t3.start();
// Wait for all
t1.join();
t2.join();
t3.join();
System.out.println("\nAll files processed!");
}
}
Output
[Output of that]
Method 3: Anonymous Class
java example
public class AnonymousThread {
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Anonymous Class Threads ===\n");
// Anonymous Thread subclass
Thread t1 = new Thread() {
@Override
public void run() {
System.out.println("Anonymous Thread running: " + getName());
}
};
// Anonymous Runnable
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Anonymous Runnable running: " +
Thread.currentThread().getName());
}
}, "AnonRunnable");
t1.start();
t2.start();
t1.join();
t2.join();
}
}Output
=== Anonymous Class Threads === Anonymous Thread running: Thread-0 Anonymous Thread running: Thread-1 Both anonymous threads completed.
Method 4: Lambda Expression (Java 8+) — Preferred
Example
public class LambdaThread {
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Lambda Thread Creation (Modern Java) ===\n");
// Simple lambda — most concise way
Thread t1 = new Thread(() -> {
System.out.println("Lambda thread: " + Thread.currentThread().getName());
for (int i = 0; i < 3; i++) {
System.out.println(" Working... " + i);
try { Thread.sleep(100); } catch (InterruptedException e) { return; }
}
}, "Lambda-Worker");
// One-liner for simple tasks
Thread t2 = new Thread(() -> System.out.println("Quick task done!"), "Quick");
// Using method reference
Thread t3 = new Thread(LambdaThread::backgroundTask, "Background");
t1.start();
t2.start();
t3.start();
t1.join();
t2.join();
t3.join();
System.out.println("\nAll lambda threads completed!");
}
static void backgroundTask() {
System.out.println("Background task via method reference: " +
Thread.currentThread().getName());
}
}
Output:
Example
=== Lambda Thread Creation (Modern Java) ===
Lambda thread: Lambda-Worker
Quick task done!
Background task via method reference: Background
Working... 0
Working... 1
Working... 2
All lambda threads completed!
start() vs run() — Critical Difference!
java example
public class StartVsRun {
public static void main(String[] args) {
Runnable task = () -> {
System.out.println(" Task running on: " + Thread.currentThread().getName());
};
Thread thread = new Thread(task, "MyThread");
System.out.println("=== start() vs run() ===\n");
System.out.println("Main thread: " + Thread.currentThread().getName());
// WRONG: Calling run() directly
System.out.println("\nCalling run() directly:");
thread.run(); // Runs on MAIN thread! No new thread created!
// CORRECT: Calling start()
System.out.println("\nCalling start():");
thread.start(); // Creates NEW thread, then calls run() on it
try { Thread.sleep(100); } catch (InterruptedException e) {}
}
}Output:
| Main thread | main |
| Task running on | main |
| Task running on | MyThread |
Key Rule: Always call start(), never run() directly!
start()→ new thread created, run() invoked on itrun()→ just a normal method call on the current thread
Thread vs Runnable — When to Use Which?
Example
// ❌ Problem with extending Thread: Can't extend another class
class Animal {
void eat() { System.out.println("Eating"); }
}
// This won't work — Java doesn't support multiple inheritance!
// class Cat extends Animal extends Thread { } // COMPILE ERROR!
// ✅ Solution with Runnable: Can implement + extend
class Cat extends Animal implements Runnable {
@Override
public void run() {
eat(); // Can access parent class methods!
System.out.println("Cat is hunting (Thread: " + Thread.currentThread().getName() + ")");
}
}
public class ThreadVsRunnable {
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Thread vs Runnable ===\n");
Cat cat = new Cat();
Thread catThread = new Thread(cat, "CatThread");
catThread.start();
catThread.join();
System.out.println("\n--- Comparison ---");
System.out.println("┌──────────────────┬────────────────────────────────────┐");
System.out.println("│ Thread (extends) │ Runnable (implements) │");
System.out.println("├──────────────────┼────────────────────────────────────┤");
System.out.println("│ Can't extend │ Can extend another class │");
System.out.println("│ other classes │ (more flexible) │");
System.out.println("├──────────────────┼────────────────────────────────────┤");
System.out.println("│ Each instance = │ Same Runnable shared by many │");
System.out.println("│ separate thread │ threads (resource sharing) │");
System.out.println("├──────────────────┼────────────────────────────────────┤");
System.out.println("│ Tightly coupled │ Separates task from thread │");
System.out.println("│ to Thread class │ (better design) │");
System.out.println("├──────────────────┼────────────────────────────────────┤");
System.out.println("│ Older approach │ Preferred in modern Java │");
System.out.println("└──────────────────┴────────────────────────────────────┘");
}
}
Output
[Output of class]
Sharing a Runnable Among Multiple Threads
Example
class SharedCounter implements Runnable {
private int count = 0;
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
count++; // ⚠️ Not thread-safe (demo purposes)
}
System.out.println(Thread.currentThread().getName() + " finished. Count = " + count);
}
public int getCount() { return count; }
}
public class SharedRunnableDemo {
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Sharing Runnable Between Threads ===\n");
// Same Runnable instance shared by 3 threads
SharedCounter counter = new SharedCounter();
Thread t1 = new Thread(counter, "Thread-A");
Thread t2 = new Thread(counter, "Thread-B");
Thread t3 = new Thread(counter, "Thread-C");
t1.start();
t2.start();
t3.start();
t1.join();
t2.join();
t3.join();
System.out.println("\nFinal count: " + counter.getCount());
System.out.println("Expected: 3000 (but may be less due to race condition!)");
System.out.println("This demonstrates why synchronization is needed.");
}
}
Output (may vary):
Example
=== Sharing Runnable Between Threads ===
Thread-A finished. Count = 2156
Thread-B finished. Count = 2789
Thread-C finished. Count = 2934
Final count: 2934
Expected: 3000 (but may be less due to race condition!)
This demonstrates why synchronization is needed.
Real-World Example: Parallel File Downloader
Example
import java.util.concurrent.atomic.AtomicInteger;
public class ParallelDownloader {
private static AtomicInteger completedCount = new AtomicInteger(0);
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Parallel File Downloader ===\n");
String[] files = {
"document.pdf (2.5 MB)",
"video.mp4 (150 MB)",
"archive.zip (45 MB)",
"image.png (3.2 MB)",
"database.sql (12 MB)"
};
Thread[] threads = new Thread[files.length];
long startTime = System.currentTimeMillis();
for (int i = 0; i < files.length; i++) {
final String file = files[i];
threads[i] = new Thread(() -> downloadFile(file), "DL-" + (i + 1));
threads[i].start();
}
// Wait for all downloads
for (Thread t : threads) {
t.join();
}
long totalTime = System.currentTimeMillis() - startTime;
System.out.printf("%n✓ All %d files downloaded in %d ms%n", files.length, totalTime);
System.out.println(" (Sequential would take ~" + (files.length * 500) + " ms)");
}
static void downloadFile(String filename) {
System.out.printf(" [%s] Starting: %s%n", Thread.currentThread().getName(), filename);
// Simulate download time
try { Thread.sleep(300 + (int)(Math.random() * 400)); }
catch (InterruptedException e) { return; }
int done = completedCount.incrementAndGet();
System.out.printf(" [%s] ✓ Completed: %s [%d/5]%n",
Thread.currentThread().getName(), filename, done);
}
}
Output:
| [DL-1] Starting | document.pdf (2.5 MB) |
| [DL-2] Starting | video.mp4 (150 MB) |
| [DL-3] Starting | archive.zip (45 MB) |
| [DL-4] Starting | image.png (3.2 MB) |
| [DL-5] Starting | database.sql (12 MB) |
| [DL-4] ✓ Completed | image.png (3.2 MB) [1/5] |
| [DL-1] ✓ Completed | document.pdf (2.5 MB) [2/5] |
| [DL-3] ✓ Completed | archive.zip (45 MB) [3/5] |
| [DL-5] ✓ Completed | database.sql (12 MB) [4/5] |
| [DL-2] ✓ Completed | video.mp4 (150 MB) [5/5] |
Common Mistakes
1. Calling run() instead of start()
java example
// ❌ WRONG: No new thread created
thread.run(); // Executes on current thread
// ✅ CORRECT: New thread created
thread.start(); // New thread → calls run()2. Starting a thread twice
java example
Thread t = new Thread(() -> System.out.println("Task"));
t.start();
t.start(); // ❌ IllegalThreadStateException!
// ✅ Create a new Thread instance for each execution3. Not handling InterruptedException
java example
// ❌ BAD: Swallowing the interrupt
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// Empty — bad practice!
}
// ✅ GOOD: Restore interrupt status or handle properly
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // Restore interrupt flag
return; // Exit gracefully
}Interview Questions
Q1: What are the two ways to create a thread in Java?
Answer: (1) Extend Thread class and override run(), (2) Implement Runnable interface and pass to Thread constructor. Implementing Runnable is preferred because it allows extending another class and better separates task logic from threading mechanism.
Q2: What is the difference between start() and run()?
Answer: start() creates a new OS-level thread and invokes run() on that new thread. run() is just a normal method — calling it directly executes on the current thread with no new thread creation. Always use start() for multithreading.
Q3: Can we start a thread twice?
Answer: No. Calling start() on an already-started thread throws IllegalThreadStateException. Once a thread has terminated, it cannot be restarted. You must create a new Thread instance.
Q4: Why is implementing Runnable preferred over extending Thread?
Answer: (1) Java supports only single inheritance — extending Thread prevents extending other classes. (2) Runnable separates the task from the execution mechanism (better OOP design). (3) A single Runnable can be shared among multiple threads. (4) Runnable works with ExecutorService and thread pools.
Q5: Can a Runnable be used without creating a Thread object?
Answer: Yes! Runnables can be submitted to ExecutorService, used with ScheduledExecutorService, or executed directly with runnable.run() (though that won't create a new thread). The flexibility of Runnable is why it's preferred.
Q6: What is the difference between Callable and Runnable?
A: Runnable's run() returns void and cannot throw checked exceptions. Callable's call() returns a value (generic type V) and can throw checked exceptions. Callable is used with ExecutorService and returns a Future for retrieving the result asynchronously.
Q7: Can we create a thread using lambda expression?
A: Yes! Since Runnable is a functional interface (single abstract method), you can use lambdas: new Thread(() -> System.out.println("Running")).start(). This is the most concise way to create simple threads in Java 8+.
Q8: What happens if you call start() on a thread that's already started?
A: It throws IllegalThreadStateException. Once a thread has been started (regardless of whether it's still running or has terminated), it cannot be started again. You must create a new Thread instance for re-execution.
Q9: How do you pass data to a thread?
A: (1) Constructor parameters (in your Thread subclass or Runnable implementation), (2) Shared objects (passed by reference), (3) Instance variables, (4) Using Callable with Future for return values. Avoid sharing mutable state without synchronization.
Q10: What is the difference between user threads and daemon threads at creation time?
A: By default, new threads inherit the daemon status of their parent thread. Since main is a user thread, child threads are user threads by default. Call thread.setDaemon(true) before start() to make it a daemon thread. The JVM exits when only daemon threads remain.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Creating Threads 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, creating, thread
Related Java Master Course Topics
Continue learning this concept
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.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.MultithreadingThread Class in JavaComplete guide to the Thread class in Java — constructors, important methods (sleep, join, yield, interrupt), thread naming, thread groups, and practical usage patterns.MultithreadingThread IntroductionComplete introduction to Multithreading in Java — what threads are, processes vs threads, why multithreading matters, concurrency vs parallelism, and how the JVM manages threads.MultithreadingThread Life Cycle in JavaComplete guide to Thread Life Cycle states in Java — NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED, state transitions, and how to observe thread states programmatically.MultithreadingThread Priority in JavaComplete guide to Thread Priority in Java — priority constants, setting priorities, how the thread scheduler uses priorities, priority inheritance, and why priorities are unreliable for correctness.