Doing some studying about threads and I'm confused about what the start() method in Java threads actually do.
My current understanding is that the start method doesn't immediately start the thread's execution, but instead moves it to a pool of threads waiting for it be picked for execution by the thread scheduler.
Is this correct? I can't seem to find any good resources about what the methods actually do.
Exactly, when a call to start() is performed, it just schedules the call to run(). You cannot determinate when the thread will effectively be launched, nor when it will effectively be stopped.
You can find more information in the Java Doc on oracle's website.
start
public void start() Causes this thread to begin execution; the Java
Virtual Machine calls the run method of this thread. The result is
that two threads are running concurrently: the current thread (which
returns from the call to the start method) and the other thread (which
executes its run method).
Throws: IllegalThreadStateException - if the thread was already
started. See Also: run(), stop()
Source
You are confusing Threads with ThreadPools
A thread is an "unit of execution", code executed on a separate thread runs in parallel with your main programs when you call start()
ThreadPools is a mechanism built on top of threads, it allows you to create a group of threads which will take care to execute tasks you submit to the ThreadPool queue.
Yes, this is correct. You don't know when this thread will be executed but for sure it is scheduled for running.
Have a look at the following picture. It explains the lifecycle of a thread: http://cs.fit.edu/~ryan/java/language/thread.gif
start immediately starts the new thread, but by the very nature of threads, there is no guarantee as to when any line of code in that thread will actually execute. It is not appropriate to use the term "thread pool" in this context because the concept of a pool involves resources that are reused between user-requested tasks. A Thread instance is hardwired to a single invocation of the run method, after which the thread dies.
The thread scheduler is a native OS-level component and is not under the direct control of the JVM.
When you call Thread.start it makes a special instarcution to JVM for starting a thread and JVM will taken care of its life cycle.
Related
I'm new to concurrent programming in Java. I've noticed that the methods sleep() and currentThread() of the Thread class are static. Since with a multi-core CPU, many threads can run at the same time, I was wondering how the thread is chosen between the ones in execution. Thank you.
That's easily found in the Javadocs for Thread:
For currentThread():
Returns a reference to the currently executing thread object.
For sleep():
Causes the currently executing thread to sleep
I.e. the Thread that calls the method for both methods.
Can some body help me to understand my below questions:-
When new stack is created? On executing Thread t=new Thread() or t.start()
How start() method calls implemented run()?
Can we assign memory to each thread like JVM? If NO, how JVM will modify stack memory of running thread.
From the Javadoc of Thread:
A thread is a thread of execution in a program. The Java Virtual Machine allows an application to have multiple threads of execution running concurrently.
Every thread has a priority. Threads with higher priority are executed in preference to threads with lower priority. Each thread may or may not also be marked as a daemon. When code running in some thread creates a new Thread object, the new thread has its priority initially set equal to the priority of the creating thread, and is a daemon thread if and only if the creating thread is a daemon.
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.
Now, to your questions.
When [is a] new stack is created? On executing Thread t=new Thread() or t.start()?
A new thread is created by the constructor. It is run with the start method.
How [does] start() method calls implemented run()?
From the source code of Thread:
public void run() {
if (target != null) {
target.run();
}
}
Can we assign memory to each thread like JVM? If No, how JVM will modify stack memory of running thread.
No, you cannot assign memory to each thread. The operating system (Windows, Unix, OS X) controls how threads are created and destroyed. The JVM has access to every thread through a string identifier.
You can read the Thread source code for more information about the Thread class.
The Stack is created while the Start() method is called as till then the required info to create
the stack is not available.
The Thread class you call has this coded behind that calls run within its start method.
[In fact it is the Start() method that actually creates a new thread (not Thread class but the
real process thrad) and calls run() in the new thread. for eg: if you call run() instead of start
() in your runnable class. No new thread will be created.]
No. We cant assign Specific amount of memory to a thread.
I have tried some sample code along the lines of:
Thread thread = new TestThread();
thread.start();
thread.isAlive();
It appears to me that the only way for the isAlive() call to return false, is for the thread to have already finished. Is this true?
The Java 7 JavaDoc for start:
Causes this thread to begin execution; the Java Virtual Machine calls the run method of this thread.
The result is that two threads are running concurrently: the current thread (which returns from the call to the start method) and the other thread (which executes its run method).
It is never legal to start a thread more than once. In particular, a thread may not be restarted once it has completed execution.
The Java 7 JavaDoc for isAlive:
Tests if this thread is alive. A thread is alive if it has been started and has not yet died.
Neither of these seem very conclusive to me.
The statement someThread.start() will cause that thread to go into
runnable state
It is not guaranteed that it will start executing its run method immediately after start() is called.
Exactly when to execute the thread, is totally dependent on the thread scheduler.
When someThread.start() is called, the thread can move from runnable to runing state and even waiting state.
Tests if this thread is alive. A thread is alive if it has been started and has not yet died.
This means, the thread is alive when its start() is called and its run() not completed yet. Completion of run() method means thread is dead.
Thread has started doesn't mean it is already executing run method but it's status is Alive.
So after start is returned Thread is alive but not guaranteed to be executing run method it's state can be anything except New after completion of start method. (Runnable, Waiting, Terminated, etc)
t.isAlive() returns true if t is not in the NEW or TERMINATED state
Also take a look at this great resource on java threading
A thread t is alive as soon as t.start() returns and until t.run() completes.
I was teaching myself Java threading and I noticed something that confuses me a little. I made a class called engine implementing Runnable. The run method just prints "Hello World", sleeps for a second, and repeats.
In my main method, I have:
public static void main(String[] args) {
Thread thread = new Thread(engine);
thread.start();
System.out.println("Done.");
}
As I expected, I see "Hello World" and "Done." printed quickly, meaning the main method has reached the end, but what I didn't expect was that the thread I started kept running even after the end of main was reached.
Why does the program continue to execute even after main exits? I would have thought that when main exited the process would terminate and all of the threads would be cleaned up forcefully. Does this mean that every thread has to be joined/killed explicitly for a Java program to terminate?
Because that's how it works. The program exits when System.exit() is called, or when the last non-daemon thread stops running.
And it makes sense. Without this rule, every Java program consisting in just spawning a GUI, for example, would have to wait() infinitely to avoid the program from exiting immediately.
If you want your program to exit when the main method finished, consider making your threads daemons. But take care of the fact, that daemon threads will be aborted, when main finishes.
You can create a daemon thead like so:
Thread t = new Thread(...);
t.setDaemon(true);
All non-daemon threads are user threads. Those threads are stopping the jvm from closing.
User threads continue to run independently of the lifetime of their parent thread, i.e, the creator thread. So, you have to join the threads explicitly by invoking Thread.join before the main thread terminates.
From the Javadoc of Thread:
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.
If you want JVM to terminate even if a thread t is running, you should make thread t a daemon thread:
t.setDaemon(true);
There are two types of threads, user and daemon. The process terminates when there are no more user threads. The main thread is always a user thread. The thread that you start is also a user thread, and therefore keeps the process alive for as long as it runs.
Calling setDaemon(true) on your thread before you start it will make your process terminate (more or less) as soon are your main() function returns.
The Java Language Specification section 12.8 indicates:
12.8. Program Exit
A program terminates all its activity and exits when one of two things
happens:
All the threads that are not daemon threads terminate.
Some thread invokes the exit method of class Runtime or class System,
and the exit operation is not forbidden by the security manager.
This means it is not enough for the main thread to finish.
If you do want it to exit when the main thread ends you need to either make the new thread a daemon by using Thread#setDaemon or use Thread#join as you initially suggested.
The main thread is also a user thread which is being created and its lifecylce is similar to any other user thread for that matter.
The other user threads are not dependent on the main thread for any reason unless you set the threads as daemon threads.
Once the main thread completes its work it ends(it neither ends the other user threads nor will end the process because the other user threads are running).
Java Thread can have begining,end and sequence,What does that mean?
I think all it means is that a thread executes a sequence of actions. It's expressing that concept pretty badly, to be honest.
In other words:
You create a Thread, ideally passing it a Runnable. (You can extend Thread instead and override its run method but that's generally frowned upon.)
You call start on it
The thread which called start continues executing the next statement in its program
The run method executes in the separate thread, independently of the thread that started it. The behaviour in here is what I believe is meant by the "sequence"
The new thread eventually ends due to one of the following conditions:
Its run method completes normally
Its run method completes with an exception
If it's a daemon thread, it can terminate as part of the JVM terminating due to all the non-daemon thread exiting