Is there a semantic difference between the terms call stack
and thread stack
, in Java multithreading?
A call stack
is a stack data structure
that stores information about the active subroutines of a computer program.
What you're calling a thread stack
is what i assume is the private stack of a thread.
These two things are essentially the same. They are both stack data structures
.
A thread's stack is used to store the location of function calls in order to allow return statements to return to the correct location
Since there usually is only one important call stack, it is what people refer to as the stack.
Here is information about the stack.
Here is information about Stack-based memory allocation.
Each thread has its own call stack, "call stack" and "thread stack" are the same thing. Calling it a "thread stack" just emphasizes that the call stack is specific to the thread.
Bill Venners calls this the Java stack:
When a new thread is launched, the Java virtual machine creates a new Java stack for the thread. As mentioned earlier, a Java stack stores a thread's state in discrete frames. The Java virtual machine only performs two operations directly on Java Stacks: it pushes and pops frames.
The method that is currently being executed by a thread is the thread's current method. The stack frame for the current method is the current frame. The class in which the current method is defined is called the current class, and the current class's constant pool is the current constant pool. As it executes a method, the Java virtual machine keeps track of the current class and current constant pool. When the virtual machine encounters instructions that operate on data stored in the stack frame, it performs those operations on the current frame.
When a thread invokes a Java method, the virtual machine creates and pushes a new frame onto the thread's Java stack. This new frame then becomes the current frame. As the method executes, it uses the frame to store parameters, local variables, intermediate computations, and other data.
Each thread has its own stack, each method call uses a new area of that stack. This means when a method calls itself (recursion), it will have a new set of local variables.
When FileWriter
throws an IOException
, the runtime system immediately stops executing the try
block; method calls being executed are not completed. The runtime system then starts searching at the top of the method call stack for an appropriate exception handler.
In this example, when the IOException
occurs, the FileWriter
constructor is at the top of the call stack. However, the FileWriter
constructor doesn't have an appropriate exception handler, so the runtime system checks the next method — the writeList
method — in the method call stack. The writeList
method has two exception handlers: one for IOException
and one for IndexOutOfBoundsException
.