will main thread exit before child threads complete execution?

Question

will main thread exit before child threads complete execution?

i read in 2 articles

http://www.cs.mtu.edu/~shene/NSF-3/e-Book/FUNDAMENTALS/thread-management.html

in the above article, In "Thread Termination" para, it states in Red " if the parent thread terminates, all of its child threads terminate as well."

http://www.roseindia.net/java/thread/overview-of-thread.shtml

in the above article, the last line in that page states "The main() method execution can finish, but the program will keep running until the all threads have complete its execution.".

i fee they are contradictory. if i am wrong, Please experts correct me.

In my program, a program with Main method calls the constructor of 2 threads . in the constructor of the respective threads, i am having the start() method .

     TestA  A = new TestA("TestA");
     TestB  B = new TestB("TestB");

     public TestA(String name) {
    System.out.println(name);
    t = new Thread(this);
    t.start();
}

i would like to know what happens, main thread terminates before child threads complete execution? if so, will the child threads anyway, continue their execution??

i tried running the program, some times all the child threads are getting executed complete even if the main thread exits. In the 2 threads , i am processing some files. in testA thread A alone, 1 file alone is not getting processed some times. but many times, all the files are getting processed and i do not have any issues.

Answer 1

Java makes a distinction between a user thread and another type of thread known as a daemon thread. The difference between these two types of threads is that if the JVM determines that the only threads running in an application are daemon threads (i.e., there are no user threads), the Java runtime closes down the application. On the other hand, if at least one user thread is alive, the Java runtime won't terminate your application.

When your main() method initially receives control from the Java runtime, it executes in the context of a user thread. As long as the main-method thread or any other user thread remains alive, your application will continue to execute.

In your case, the threads are user threads and hence are allowed to complete before the main thread exits.

i am processing some files. in testA thread A alone, 1 file alone is not getting processed some times. but many times

The reason for the above is could be something else than thread exits. It could be file locks, synchronization issue etc.

Thread (Java SE 10 & JDK 10):

When a Java Virtual Machine starts up, there is usually a single non-daemon thread (which typically calls the method named main of some designated class). The Java Virtual Machine continues to execute threads until either of the following occurs:

• The exit method of class Runtime has been called and the security manager has permitted the exit operation to take place.
• All threads that are not daemon threads have died, either by returning from the call to the run method or by throwing an exception that propagates beyond the run method.

Answer 2

The background threads will keep running, even if the MAIN thread completes.

If you want MAIN to stop them (example, when MAIN is complete), have your MAIN set a "keep running" flag variable (which you must set as "volatile"), which the threads occasionally look at. MAIN sets it to false (variable) or null (object) when MAIN wants to stop them. When it's false or null, then the thread must "return;".

This is somewhat complex to implement, there are many ways, but easiest is to make your Runnable an inner class, so that your Runnable has easy sharing of the flag.

For the best implementations, look up this technique in Java applets' start/stop routines.

Answer 3

Once the main thread exits, it takes the children with it. Perhaps by "finish" the second article simply means no more operation other than waiting for the children. Once the main thread calls System.exit(0); it's over -- every body dies.

Say you have two threads running: threadA and threadB. in the main method. The first code is the nice way of terminating the thread -- just one of many ways:

 threadA.start();
 threadB.start();
 final long intercept = 300;
 long startTime = System.currentTimeMillis();
 while (threadA.isAlive() && mis.isAlive()) {
    threadA.join(intercept);
if (System.currentTimeMillis() - startTime > intercept) {
   threadB.interrupt();
   threadA.interrupt();
   threadA.join();
}
}
System.exit(0);

Below is an abrupt way of killing all threads from within main:

System.exit(0);