Detailed introduction to daemon threads and user threads in Java

This article mainly introduces a brief discussion of daemon threads and user threads in Java. The editor thinks it is quite good. Now I will share it with you and give you a reference. Let’s follow the editor to take a look.

Java threads are divided into two categories: daemon threads (daemon threads) and User threads (user threads). When the JVM starts, the main function will be called, and the thread where the main function is located It is a user thread. This is the thread we can see. In fact, many daemon threads are also started inside the JVM, such as garbage collection threads. So what is the difference between daemon threads and user threads? One of the differences is that when the last non-daemon thread ends, the JVM will exit normally, regardless of whether there is currently a daemon thread, which means that whether the daemon thread ends does not affect the JVM's exit. The implication is that as long as one user thread has not ended, the JVM will not exit under normal circumstances.

So how to create a daemon thread in Java? The code is as follows:

public static void main(String[] args) {

    Thread daemonThread = new Thread(new Runnable() {
      public void run() {
        
      }
    });
    
    //设置为守护线程
    daemonThread.setDaemon(true);
    daemonThread.start();
    
  }

It can be seen that you only need to set the daemon parameter of the thread to true.

Let’s use examples to deepen our understanding of the difference between user threads and daemon threads. First, look at the following code:

public static void main(String[] args) {

    Thread thread = new Thread(new Runnable() {
      public void run() {
        for(;;){}
      }
    });
    
    //启动子线
    thread.start();
    
    System.out.print("main thread is over");
  }

The result output is:

The above code creates a thread thread in the main thread. There is an infinite loop in the thread thread. From the results of running the code, it can be seen that the main thread has finished running, so the JVM has exited. Already? The red square on the right side of the IDE output indicates that the JVM process has not exited. In addition, executing ps -eaf | grep java on
mac will output the results, which can also prove this conclusion.

This result shows that when the parent thread ends, the child thread can still exist, that is, the life cycle of the child thread is not affected by the parent thread. It also shows that the JVM process will not terminate when the user thread still exists. Then we set the above thread thread as a daemon thread and run it to see what the effect will be:

##

    //设置为守护线程
    thread.setDaemon(true);
    //启动子线
    thread.start();

The execution result is:

As above, set the thread as a daemon thread before starting the thread. From the output result, we can see that the JVM process has been terminated. You can no longer see the JVM process by executing ps -eaf |grep java. In this example, the main function is the only user thread, and the thread thread is a daemon thread. When the main thread finishes running, the JVM finds that there are no more user threads and will terminate the JVM process.

In Java, after the main thread finishes running, the JVM will automatically start a thread called DestroyJavaVM. This thread will wait for all user threads to finish and then terminate the JVM process. The following is a simple JVM code to prove this conclusion:

Open the JVM code, and eventually the c function JavaMain will be called

int JNICALL
JavaMain(void * _args)
{  
  ...
  //执行Java中的main函数 
  (*env)->CallStaticVoidMethod(env, mainClass, mainID, mainArgs);
  
  //main函数返回值
  ret = (*env)->ExceptionOccurred(env) == NULL ? 0 : 1;
  
  //等待所有非守护线程结束，然后销毁JVM进程
  LEAVE();
}

LEAVE is a macro definition in the c language, defined as follows:

#define LEAVE() \
  do { \
    if ((*vm)->DetachCurrentThread(vm) != JNI_OK) { \
      JLI_ReportErrorMessage(JVM_ERROR2); \
      ret = 1; \
    } \
    if (JNI_TRUE) { \
      (*vm)->DestroyJavaVM(vm); \
      return ret; \
    } \
  } while (JNI_FALSE)

The function of the above macro is actually to create a thread named DestroyJavaVM to wait for all user threads to end.

Summary: If you want the JVM process to end immediately after the main thread ends, you can set the thread as a daemon thread when creating the thread. Otherwise, if you want the child thread to continue working after the main thread ends, wait for the child thread to end. After letting the JVM process end, set the child thread as a user thread. The open source framework Tomcat uses daemon threads and user threads to run together. For details, please look forward to the publication of the book Concurrent Package Source Code Analysis on the Basics of Java Concurrent Programming.

The above is the detailed content of Detailed introduction to daemon threads and user threads in Java. For more information, please follow other related articles on the PHP Chinese website!