创建了多少个线程？

Question

In one of the interview i came across query on threads.Question is in the below code snippet, how many threads are being created? I know it's seems to be very basic query. But i couldn't find answer with proof.

Could someone provide me answer with the concept(any links)? Thanks in anticipation.

class MainApp {
    public static void main(String[] args) {
        System.out.println("Welcome to Java");
    }
}

Answer 1

Since your simple program does not create threads explicitly only one application thread is created here. This is the "correct" short answer at the interview.

However you can continue and say that JVM creates other threads it needs for itself. For example garbage collector (GC) thread. Number of GC threads depends on configuration. By default 1.

Answer 2

If the question is literally:

In the below code snippet , how many threads are being created?

...then the answer is 0 . The code snippet doesn't create any threads in and of itself. Of course, a thread gets created for that code to run in, and since that code doesn't create any more, another sensible answer would be 1. But if you're talking about how many threads the VM is using, then that's going to (usually) be at least two (for GC), most of the time more (dispatcher, reference handler, finalizer etc.) but entirely dependent on configuration. Even then, it won't always be two, you can have a perfectly conforming JVM that doesn't do garbage collection at all (and indeed the early JavaCard VM's did exactly this.)

Of course, that assumes that the interviewer was asking about Java threads - if we go down to the OS level, then again we have a further level of unknowns as to exactly how the system is printing out the above string, if at all!

Given the above, my response would have been to clarify what exactly the interviewer meant by the question - because in and of itself, it's a bit ambiguous and not a great question at all in my opinion. It reads like a trick question, but without enough information to answer it properly - whatever answer you gave, without further clarification, could be deemed incorrect. Though as NoobUnchained has posted already, mentioning you can use Thread.activeCount() to grab the number of VM threads in use wouldn't go against you.

Of course, perhaps the purpose of the question was not so much for a technical answer but to see if you would clarify what exactly was meant by it at interview - not an unheard of tactic!

Answer 3

When a program is running, there are threads that we create that are running. In your case, it's a simple program, then there is a main thread which executed the main method . Also there might few daemon threads run by the JVM (ie maybe the garbage collector and more).

Answer 4

The correct answer is "I don't know" I got these threads created:

 Signal Dispatcher
 main
 Finalizer
 Reference Handler
 Monitor Ctrl-Break

It can depend on the jvm and its configuration.

Answer 5

It all depends which thread you are trying to count. There are two types of threads being created by the JVM one is application level thread and the others are System level threads.

So atleast one thread is created which is the main thread and many System threads such as for memory management (Garbage Collection) etc.

If you take your code for example only 1 application level thread is created which is the main thread. And the code itself doesn't create further threads.

So a precise answer will be 1 application level thread (Main thread) and many System level threads

Read below Reference copied from Java Documentation:

http://docs.oracle.com/javase/tutorial/essential/concurrency/procthread.html

Multithreaded execution is an essential feature of the Java platform. Every application has at least one thread — or several, if you count "system" threads that do things like memory management and signal handling. But from the application programmer's point of view, you start with just one thread, called the main thread. This thread has the ability to create additional threads, as we'll demonstrate in the next section.