A thread is a lightweight subprocess and the smallest unit of processing in a program.

 It operates as a separate path of execution within the program.

Threads are independent of each other. If one thread encounters an exception or error, it does not impact the execution of other threads. Threads share a common memory area, allowing them to efficiently communicate and coordinate their activities

As depicted in the figure above, a thread operates within a process. 

Within a single process, threads can switch between execution contexts, enabling concurrent execution of multiple threads.

It's important to note that an operating system can host multiple processes, and each of these processes can contain multiple threads. This structure allows for the efficient utilization of system resources and parallel execution of tasks within and between processes

The Main Thread

You can obtain a reference to the currently executing thread by using the currentThread() method.

To modify the internal name of a thread, you can utilize the setName() method.

To introduce a pause or delay in a thread's execution, you can use the sleep() method. The duration of the pause is determined by the argument provided to sleep(), which specifies the delay period in milliseconds.

It's important to note that when using the sleep() method in the Thread class, it may potentially throw an InterruptedException. This exception occurs if another thread requests the interruption of the sleeping thread while it is in the sleeping state.

Java offers the Thread class as a fundamental tool for thread programming, supplying constructors and methods for thread management. The Thread class is an extension of the Object class and implements the Runnable interface, enabling the creation and execution of threads with ease. 

The concept and life cycle of threads

In Java, a thread always exists in one and only one of the following states at any given moment. It does not occupy multiple states simultaneously.

1. New

2. Active

3. Blocked / Waiting

4. Timed Waiting

5. Terminated

The diagram below illustrates the different states a thread can be in at a particular moment in time.

Life Cycle of a Thread 

The life cycle of a thread in Java represents the various states through which a thread passes during its execution. Here's a more detailed explanation of the life cycle of a Java thread:

1. New Thread (New State): When a new thread is created, it enters the "new" state. In this state, the thread's code hasn't started executing, and it's awaiting its turn to run.

2. Runnable State: Threads in the "runnable" state are ready to run but may or may not be currently executing. The thread scheduler decides when each thread gets CPU time. In a multi-threaded program, threads take turns running for a short duration before giving way to others.

3. Blocked State: Threads enter the "blocked" state when they attempt to acquire a lock currently held by another thread. They remain blocked until they successfully acquire the lock, at which point they return to the "runnable" state.

4. Waiting State: Threads can enter the "waiting" state when they call methods like wait() or join(). They stay in this state until another thread notifies them or the waiting thread is terminated.

5. Timed Waiting State: Threads in the "timed waiting" state are waiting for a specified period or until they receive a notification. This state is entered when a thread calls methods with a time-out parameter, such as sleep() or a conditional wait.

6. Terminated State: Threads can terminate for two main reasons:

• • • • They exit normally after completing their code execution.

      • They encounter unusual errors, like unhandled exceptions or segmentation faults, leading to unexpected termination.

Java, you can use the Thread.getState() method to get the current state of a thread. The java.lang.Thread.State class defines the ENUM constants that represent the states of a thread. Here's a summary of the Thread.State constants: 

Sample code to create Threads by Extending Thread Class 

Java Program to explore different Thread States:-