Java/J2EE and SOA (348 Blogs) Become a Certified Professional
AWS Global Infrastructure

Programming & Frameworks

Topics Covered
  • C Programming and Data Structures (16 Blogs)
  • Comprehensive Java Course (4 Blogs)
  • Java/J2EE and SOA (345 Blogs)
  • Spring Framework (8 Blogs)

Threads in Java: Know Creating Threads and Multithreading in Java

Last updated on Jul 26,2023 220.7K Views

66 / 72 Blog from Java Core Concepts

Unlike many other computer languages, Java provides built-in support for multithreading. Multithreading in Java contains two or more parts that can run concurrently. A Java thread is actually a lightweight process.

This blog will introduce you to all the Java Thread concepts which many people find tricky to use and understand. So let us get started then, shall we? 

In this Java Thread blog, I would be covering following topics:

  1. What are Threads in Java?
  2. The Java Thread Model
  3. Multithreading in Java
  4. Main Java Thread
  5. How to Create a Java Thread?

You can go through this Java Threads video lecture where our Java Training expert is discussing each & every nuance of the technology.

Java Threads Tutorial | Multithreading In Java Tutorial | Edureka

This video talks about Java Threads, which is one of the core concepts of Java.

Before we proceed with the first topic of this  Java Thread blog, consider this example:- 

Imagine a stockbroker application with lots of complex capabilities.These are few of its functions:

  • To download the last stock option prices
  • To check prices for warnings
  • Analyze historical data for company XYZ

These are time-consuming functions. In a single-threaded runtime environment, these actions execute one after another. The next action can happen only when the previous one is finished.

Now, if a historical analysis takes half an hour, and the user selects to perform a download and check afterward, the warning may come too late to, buy or sell stock as a result. We just imagined the sort of application that cries out for multithreading. Ideally, the download should happen in the background (that is, in another thread). That way, other processes could happen at the same time so that, for example, a warning could be communicated instantly. All the while, the user is interacting with other parts of the application. The analysis, too, could happen in a separate thread, so the user can work with the rest of the application while the results are being calculated.

This is where Java thread helps. Let us understand Java Thread first:

What are Threads in Java?

A thread is actually a lightweight process. Unlike many other computer languages, Java provides built-in support for multithreaded programming. A multithreaded program contains two or more parts that can run concurrently. Each part of such a program is called thread and each thread defines a separate path of execution. Thus, multithreading is a specialized form of multitasking.

Next concept in this Java Thread blog is integral to the concept Threads and Multithreading.

The Java Thread Model-Why use Threads in Java?

The Java run-time system depends on threads for many things. Threads reduce inefficiency by preventing the waste of CPU cycles.

Threads exist in several states. Following are those states:  

  • New – When we create an instance of Thread class, a thread is in a new state.
  • Runnable – The Java thread is in running state.
  • Suspended – A running thread can be suspended, which temporarily suspends its activity. A suspended thread can then be resumed, allowing it to pick up where it left off.
  • Blocked – A java thread can be blocked when waiting for a resource.
  • Terminated – A thread can be terminated, which halts its execution immediately at any given time. Once a thread is terminated, it cannot be resumed. 

thread states- java thread - edureka

So, this was all about the Java Thread states. Now, let us jump to most important topic of Java threads i.e. thread class and runnable interface. We will discuss these one by one below.  

Multithreading in Java : How do Java threads work?

Thread Class and Runnable Interface

Java’s multithreading system is built upon the Thread class, its methods, and its companion interface, Runnable. To create a new thread, your program will either extend Thread or implement the Runnable interface.

The Thread class defines several methods that help manage threads.The table below displays the same:

Method Meaning
getNameObtain thread’s name
getPriorityObtain thread’s priority
isAliveDetermine if a thread is still running
joinWait for a thread to terminate
runEntry point for the thread
sleepSuspend a thread for a period of time
startStart a thread by calling its run method

Now let us see how to use a  Thread which begins with the main java thread, that all Java programs have.

Main Java Thread

Now let us see how to use Thread and Runnable interface to create and manage threads, beginning with the main java thread, that all Java programs have. So, let us discuss the main thread.

Why is Main Thread so important?

  • Because this thread effects the other ‘child’ threads
  • Because it performs various shutdown actions
  • It is created automatically when your program is started.

So, this was the main thread. Let’s see how we can create a java thread?

How to Create a Java Thread? 

Java lets you create thread in following two ways:- 

  • By implementing the Runnable interface.
  • By extending the Thread

Let’s see how both the ways help in implementing Java thread.

Runnable Interface

The easiest way to create a thread is to create a class that implements the Runnable interface.

To implement Runnable interface, a class need only implement a single method called run( ), which is declared like this:

public void run( )

Inside run( ), we will define the code that constitutes the new thread


public class MyClass implements Runnable {
public void run(){
System.out.println("MyClass running");

To execute the run() method by a thread, pass an instance of MyClass to a Thread in its constructor(constructor in Java is a block of code similar to a method that’s called when an instance of an object is created). Here is how that is done:

Thread t1 = new Thread(new MyClass ());

When the thread is started it will call the run() method of the MyClass instance instead of executing its own run() method. The above example would print out the text “MyClass running“.

Extending Java Thread

The second way to create a thread is to create a new class that extends Thread, then override the run() method and then to create an instance of that class. The run() method is what is executed by the thread after you call start(). Here is an example of creating a Java Thread subclass:

public class MyClass extends Thread {
     public void run(){
     System.out.println("MyClass running");

To create and start the above thread you can do like this:

MyClass t1 = new MyClass ();

When the run() method executes it will print out the text “MyClass running“.

So far, we have been using only two threads: the main thread and one child thread. However, our program can affect as many threads as it needs. Let’s see how we can create multiple threads.

Creating Multiple Threads

class MyThread implements Runnable {
String name;
Thread t;
    MyThread (String thread){
    name = threadname; 
    t = new Thread(this, name);
System.out.println("New thread: " + t);

public void run() {
 try {
     for(int i = 5; i > 0; i--) {
     System.out.println(name + ": " + i);
}catch (InterruptedException e) {
     System.out.println(name + "Interrupted");
     System.out.println(name + " exiting.");

class MultiThread {
public static void main(String args[]) {
     new MyThread("One");
     new MyThread("Two");
     new NewThread("Three");
try {
} catch (InterruptedException e) {
      System.out.println("Main thread Interrupted");
      System.out.println("Main thread exiting.");


The output from this program is shown here:

New thread: Thread[One,5,main]
 New thread: Thread[Two,5,main]
 New thread: Thread[Three,5,main]
 One: 5
 Two: 5
 Three: 5
 One: 4
 Two: 4
 Three: 4
 One: 3
 Three: 3
 Two: 3
 One: 2
 Three: 2
 Two: 2
 One: 1
 Three: 1
 Two: 1
 One exiting.
 Two exiting.
 Three exiting.
 Main thread exiting.

This is how multithreading in java works. This brings us to the end of Java Thread blog. I hope this was informative and helpful to you. In the next blog of Java Tutorial Blog Series, you will learn about Java Collection.

You can also learn Java through our YouTube Java Tutorial playlist. Happy Learning!! 

If you found this blog on “Java Thread useful, check out the Java Certification Training by Edureka, a trusted online learning company with a network of more than 250,000 satisfied learners spread across the globe.
Got a question for us? Please mention it in the comments section and we will get back to you or you can also join our Java Training in Sharjah.
Upcoming Batches For Java Certification Training Course
Course NameDateDetails
Java Certification Training Course

Class Starts on 8th June,2024

8th June

SAT&SUN (Weekend Batch)
View Details
  • Nice one.
    And please correct the constructor call on Line 4 in the program “Creating Multiple Threads”.

    • EdurekaSupport says:

      Hey Renju, thank you for bringing this up. We will definitely get it corrected. Thank you for reading our blogs. Do subscribe and stay connected with us. Cheers :)

  • Sankar Sankari says:

    What is the major difference between implementing Runnable or extend thread? Other than the java way of implementation

    • Himanshu Garg says:

      we can extend only one class in java…if we extend thread then we can not extend another class whereas we can implement multiple interfaces

  • Pradeep Kodavoor says:

    There is no such state called Running. State will be Runnable when Thread is running i.e. during the execution of run() method. Correct me if I am wrong!

Join the discussion

Browse Categories

webinar_success Thank you for registering Join Edureka Meetup community for 100+ Free Webinars each month JOIN MEETUP GROUP

Subscribe to our Newsletter, and get personalized recommendations.

image not found!
image not found!

Threads in Java: Know Creating Threads and Multithreading in Java