Basics of Threading in Java
Threading in Java allows you to run multiple tasks concurrently, utilizing multiple processors or cores
efficiently. Java provides built-in support for multithreading, which is essential for building high-
performance applications, especially when you want tasks to be executed in parallel (like in gaming,
GUI applications, web servers, etc.).
Here’s an overview of the basic concepts related to threads in Java:
1. What is a Thread?
A thread is a lightweight process that executes a task. Each thread runs independently, and each
thread has its own program counter, stack, and local variables. Threads share the same memory
space within a process, so they can communicate with each other more easily than processes.
2. Creating Threads in Java
There are two primary ways to create a thread in Java:
1. Extending the Thread class
You can create a thread by extending the Thread class and overriding the run() method, which
contains the code that will be executed by the thread.
• start(): It is used to initiate the thread. It internally calls the run() method of the Thread class.
• run(): Contains the code that will be executed when the thread runs.
2. Implementing the Runnable interface
Instead of extending the Thread class, you can implement the Runnable interface. This is considered
a better approach when your class already extends another class (because Java supports single
inheritance, so you can’t extend multiple classes).
3. Thread Lifecycle
A thread goes through several stages during its life cycle:
• New: When a thread is created but not yet started (i.e., you’ve created an instance but
haven’t called start()).
• Runnable: Once the thread is started using the start() method, it enters the Runnable state,
meaning it’s ready to be executed, but the operating system decides when it runs.
• Blocked: When a thread is blocked, it’s waiting for a resource (like input/output, or a lock on
an object).
• Waiting: A thread can enter this state if it’s waiting indefinitely for some condition to occur
(using wait() or join()).
• Terminated: When a thread finishes executing its run() method or when it is stopped by
some means.
4. Thread Methods
• start(): Begins the execution of the thread, calling the run() method.
• run(): Contains the code to be executed by the thread.
• sleep(long millis): Pauses the thread for the specified number of milliseconds.
• join(): Causes the current thread to wait until the thread it is called on has finished
execution.
• interrupt(): Interrupts the thread’s execution. It’s commonly used to stop a thread.
• isAlive(): Checks whether a thread is still running.
5. Thread Synchronization
Since multiple threads can access shared resources simultaneously, synchronization is needed to
avoid conflicts or inconsistencies.
1. Synchronized Methods
A method can be synchronized to ensure that only one thread at a time can execute it.
• The increment() method is synchronized, so even though both threads are calling it, only one
thread can execute it at a time.
2. Synchronized Blocks
Instead of synchronizing an entire method, you can synchronize specific blocks of code within a
method.
3. Locks (ReentrantLock)
For more advanced control, you can use explicit locks, such as ReentrantLock, for synchronization.
6. Thread Communication
Threads can communicate with each other using wait(), notify(), and notifyAll() methods.
• wait(): Makes the current thread wait until another thread invokes notify() or notifyAll() on
the same object.
• notify(): Wakes up one thread that is waiting on the object's monitor.
• notifyAll(): Wakes up all threads that are waiting on the object's monitor.
7. Executor Framework
Instead of manually managing threads, Java provides the Executor framework for thread
management. It abstracts thread creation and management.
• ExecutorService: Interface for managing and controlling thread execution.
• Executor: Provides methods for executing tasks asynchronously.
Summary of Key Threading Concepts:
• Thread: A unit of execution in Java, created using the Thread class or Runnable interface.
• Thread Lifecycle: States include new, runnable, blocked, waiting, and terminated.
• Synchronization: Prevents data inconsistency when multiple threads access shared
resources.
• Thread Communication: Allows threads to cooperate by using wait(), notify(), and notifyAll().
• Executor Framework: Manages threads more efficiently with ExecutorService.
