Main Thread in Java

Java provides built-in support for multithreaded programming. A multi-threaded program contains two or more parts that can run concurrently. Each part of such a program is called a thread, and each thread defines a separate path of execution. When a Java program starts up, one thread begins running immediately. This is usually called the main thread of our program because it is the one that is executed when our program begins.

Properties of the Main Thread

It is the thread from which other "child" threads will be spawned.
Often, it must be the last thread to finish execution because it performs various shutdown actions.

How to Control the Main Thread

The main thread is created automatically when our program is started. To control it, we must obtain a reference to it. This can be done by calling the method currentThread() which is present in the Thread class. This method returns a reference to the thread on which it is called. The default priority of the main thread is 5, and for all remaining user threads, priority will be inherited from parent to child.

Example

// Java program to control the Main Thread
 
// Importing required classes
import java.io.*;
import java.util.*;
 
// Main class extending thread class
public class Test extends Thread {
    public static void main(String[] args) {
        // Getting reference to Main thread
        Thread t = Thread.currentThread();
 
        // Getting name of Main thread
        System.out.println("Current thread: " + t.getName());
 
        // Changing the name of Main thread
        t.setName("Geeks");
        System.out.println("After name change: " + t.getName());
 
        // Getting priority of Main thread
        System.out.println("Main thread priority: " + t.getPriority());
 
        // Setting priority of Main thread to MAX(10)
        t.setPriority(MAX_PRIORITY);
        System.out.println("Main thread new priority: " + t.getPriority());
 
        for (int i = 0; i < 5; i++) {
            System.out.println("Main thread");
        }
 
        // Main thread creating a child thread
        Thread ct = new Thread() {
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("Child thread");
                }
            }
        };
 
        // Getting priority of child thread
        System.out.println("Child thread priority: " + ct.getPriority());
 
        // Setting priority of Main thread to MIN(1)
        ct.setPriority(MIN_PRIORITY);
        System.out.println("Child thread new priority: " + ct.getPriority());
 
        // Starting child thread
        ct.start();
    }
}
 
// Child Thread class
class ChildThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("Child thread");
        }
    }
}

Output

Current thread: main
After name change: Geeks
Main thread priority: 5
Main thread new priority: 10
Main thread
Main thread
Main thread
Main thread
Main thread
Child thread priority: 10
Child thread new priority: 1
Child thread
Child thread
Child thread
Child thread
Child thread

Relationship Between `main()` Method and Main Thread

For each program, a main thread is created by the JVM (Java Virtual Machine). The "Main" thread first verifies the existence of the main() method and then initializes the class. Note that from JDK 6, the main() method is mandatory in a standalone Java application.

Deadlocking with the Use of Main Thread (Only Single Thread)

We can create a deadlock by just using the main thread, i.e., by just using a single thread.

Example

// Java program to demonstrate deadlock using Main thread
 
// Main class
public class Coding75 {
    public static void main(String[] args) {
        try {
            System.out.println("Entering into Deadlock");
 
            // Joining the current thread
            Thread.currentThread().join();
 
            // This statement will never execute
            System.out.println("This statement will never execute");
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Output

Entering into Deadlock

Explanation

The statement Thread.currentThread().join(); tells the main thread to wait for itself to die. This means the main thread waits for itself to terminate, leading to a deadlock.

Java Threads Java Runnable Interface