Java 简明教程

Java - Main Thread

Main Thread in Java

每当运行 Java 程序时，主线程会自动创建。此线程负责执行 Java 程序。Java 运行时搜索主方法进行执行并基于此创建一个主线程。如果我们创建多个线程，则所有子线程都会从主线程派生。此主线程是第一个创建的线程，通常是最后一个线程，并且用于执行关闭任务。

Whenever we run a Java program, main thread is created automatically. This thread is responsible for execution of java program. Java runtime searches for main method to execute and create a main thread based on it. If we’re creating multiple threads then all child threads will be spawned from main thread. This main thread is the first thread to be created and is generally the last thread and it is used to perform shut down tasks.

How to Control Main Thread?

当程序启动时，JVM 会自动创建主线程。但是，可以通过使用不同的线程方法和技术来控制主线程。

The main thread is created by the JVM automatically when a program starts. But you can control a Main thread by using different Thread methods and techniques.

以下是一些用于控制主线程的方法。

The following are some of the methods for controlling the Main thread.

  1. sleep() Method

  2. join() Method

  3. interrupt() Method

Example of Java Main Thread

在此示例中，我们演示了一个简单的单线程程序，其中我们未声明任何线程并在程序执行中检查线程名称。

In this example, we’re showing a simple one thread program where we’re not declaring any thread and checking the thread name in the program execution.

package com.tutorialspoint;
public class TestThread {
   public void printName() {
	   System.out.println("Thread Name: " + Thread.currentThread().getName());
	   System.out.println("Thread Priority: " +Thread.currentThread().getPriority());
   }
   public static void main(String args[]) {
	   TestThread thread = new TestThread();
	   thread.printName();
   }
}
Thread Name: main
Thread Priority: 5

More Example of Main Thread

Example

在此示例中，我们创建了一个 ThreadDemo 类，该类扩展了 Thread 类。我们不向 Thread 传递任何名称，它将打印系统分配给线程的默认名称。在 main 方法中，我们创建了两个线程。在输出中，您可以检查当前线程名称已打印为 main，而线程是使用 constructor() 方法调用创建的。

In this example, we’ve created a ThreadDemo class which extends Thread class. We’re not passing any name to the Thread and it will print the default names assigned to the threads by the system. In main method, we’ve created two threads. In output, you can check, current thread name is printed as main while threads are created using constructor() method call.

package com.tutorialspoint;
class ThreadDemo extends Thread {
   ThreadDemo( ) {
      System.out.println("Thread: " + Thread.currentThread().getName() + ", " + "State: New");
   }
   public void run() {
      System.out.println("Thread: " + Thread.currentThread().getName() + ", " + "State: Running");
      for(int i = 4; i > 0; i--) {
         System.out.println("Thread: " + Thread.currentThread().getName() + ", " + i);
      }
      System.out.println("Thread: " + Thread.currentThread().getName() + ", " + "State: Dead");
   }
   public void start () {
      System.out.println("Thread: " + Thread.currentThread().getName() + ", " + "State: Start");
      super.start();
   }
}
public class TestThread {
   public static void main(String args[]) {
	  ThreadDemo thread1 = new ThreadDemo();
	  ThreadDemo thread2 = new ThreadDemo();
	  thread1.start();
	  thread2.start();
   }
}
Thread: main, State: New
Thread: main, State: New
Thread: main, State: Start
Thread: main, State: Start
Thread: Thread-0, State: Running
Thread: Thread-0, 4
Thread: Thread-0, 3
Thread: Thread-1, State: Running
Thread: Thread-1, 4
Thread: Thread-0, 2
Thread: Thread-1, 3
Thread: Thread-0, 1
Thread: Thread-1, 2
Thread: Thread-0, State: Dead
Thread: Thread-1, 1
Thread: Thread-1, State: Dead

Example 2

在此示例中，我们创建了一个 ThreadDemo 类，该类扩展了 Thread 类。我们不向 Thread 传递任何名称，它将打印系统分配给线程的默认名称。在 main 方法中，我们创建了两个线程。在输出中，您可以检查当前线程名称已打印为 main，而线程是使用 constructor() 方法调用创建的。在 main 方法的最后，我们打印主线程的状态。

In this example, we’ve created a ThreadDemo class which extends Thread class. We’re not passing any name to the Thread and it will print the default names assigned to the threads by the system. In main method, we’ve created two threads. In output, you can check, current thread name is printed as main while threads are created using constructor() method call. In the end of main method, we’re printing the state of main thread.

package com.tutorialspoint;
class ThreadDemo extends Thread {
   ThreadDemo( ) {
      System.out.println("Thread: " + Thread.currentThread().getName() + ", " + "State: New");
   }
   public void run() {
      System.out.println("Thread: " + Thread.currentThread().getName() + ", " + "State: Running");
      for(int i = 4; i > 0; i--) {
         System.out.println("Thread: " + Thread.currentThread().getName() + ", " + i);
      }
      System.out.println("Thread: " + Thread.currentThread().getName() + ", " + "State: Dead");
   }
   public void start () {
      System.out.println("Thread: " + Thread.currentThread().getName() + ", " + "State: Start");
      super.start();
   }
}
public class TestThread {
   public static void main(String args[]) {
	  ThreadDemo thread1 = new ThreadDemo();
	  ThreadDemo thread2 = new ThreadDemo();
	  thread1.start();
	  thread2.start();
      System.out.println("Thread: " + Thread.currentThread().getName() + ", " + "State: Dead");
   }
}
Thread: main, State: New
Thread: main, State: New
Thread: main, State: Start
Thread: main, State: Start
Thread: Thread-0, State: Running
Thread: main, State: Dead
Thread: Thread-1, State: Running
Thread: Thread-0, 4
Thread: Thread-1, 4
Thread: Thread-1, 3
Thread: Thread-1, 2
Thread: Thread-1, 1
Thread: Thread-1, State: Dead
Thread: Thread-0, 3
Thread: Thread-0, 2
Thread: Thread-0, 1
Thread: Thread-0, State: Dead

在此输出中，您可以检查到主线程在早期阶段已完成，但线程仍在运行并已完成其执行。

In this output, you can check that main thread was finished in earlier stages but threads were still running and finished their execution.