Creating a thread in Java

What is a Process

A process refers to the active execution of a computer program, and it can be carried out by either a single processor or a group of processors. A process encompasses various components, including a virtual address space, executable code, open handles to system objects, a security context, a distinct process identifier, environment variables, a priority class, configurable minimum and maximum working set sizes, as well as at least one thread of execution.

What is a Thread

A thread is a schedulable entity within a process, representing a fundamental unit of CPU utilization that includes a program counter, a stack, a set of registers, and a unique thread ID. Threads within a process share the same virtual address space and system resources, distinguishing them from processes.

Threads are execution contexts, while processes encompass a collection of resources related to a computation, and a process can consist of one or multiple threads. While the implementation of threads and processes varies across operating systems, typically, a thread is considered a constituent part of a process.

Threads in Java

A thread represents an independent pathway of execution within a program, allowing for the execution of a sequence of instructions autonomously from other code. In Java, threads provide a lightweight mechanism for implementing multiple concurrent execution paths within an application. While a thread resembles a sequential program with a defined beginning, end, and execution sequence, it is not a standalone program but rather operates within a larger program.

Multiple threads can run concurrently within a program, and every Java program includes at least one thread, known as the main thread, which is created by the Java Virtual Machine (JVM) during program initiation when the main() method is invoked. Each thread is an object with its own registers, stack, and code segment, capable of running in parallel with other threads within a process. The creation and management of threads in Java are facilitated by the java.lang.Thread class, enabling the execution of multiple threads concurrently, either asynchronously or synchronously.

How to create thread in Java

There are two ways to create a thread in Java:

  1. Extending Thread class
  2. Implementing Runnable interface

Extending Thread class in Java

It is possible to create a custom thread class by extending the java.lang.Thread class and overriding its run() method. By doing so, we can define the specific behavior that the thread should execute. After creating an instance of the custom thread class, we can invoke the start() method to initiate the execution of the overridden run() method in a separate thread.

public class TestClass extends Thread{ public void run(){ System.out.println("Print this....."); } public static void main(String[] args) { TestClass tc = new TestClass(); tc.start(); } }

Implementing Runnable interface in Java

In Java, an alternative approach to creating a custom thread is by implementing the java.lang.Runnable interface and providing an implementation for the public void run() method. To utilize this class as a thread, you would need to create a Thread object and pass an instance of the implemented Runnable class as a parameter. Then, by invoking the start() method on the Thread object, the run() method of the Runnable implementation will be executed in a separate thread.

public class TestClass implements Runnable{ public void run(){ System.out.println("Print this....."); } public static void main(String[] args) { TestClass tc = new TestClass(); Thread tr = new Thread(tc); tr.start(); } }

It is crucial to understand that when you extend the Thread class in Java, you lose the ability to extend any other class since Java does not support multiple inheritance. On the other hand, implementing the Runnable interface allows for more flexibility, as it leaves open the option to extend another class in the future or simultaneously, freeing up the inheritance hierarchy for your class.


Threads can be created by either extending the Thread class and overriding the run() method or by implementing the Runnable interface and providing an implementation for the run() method, offering different trade-offs between flexibility and inheritance.