Threads each have their own stack, but they share a common heap.
Its clear to everyone that stack is for local/method variables & heap is for instance/class variables.
What is the benefit of sharing heap among threads.
There are several number of threads running simultaneously, so sharing memory can lead to issues such as concurrent modification, mutual exclusion etc overhead. What contents are shared by threads in heap.
Why is this the case? Why not have each thread own its own heap as well? Can anyone provide a real world example of this, how shared memory is utilized by threads?
Advertisement
Answer
What do you do when you want to pass data from one thread to another? (If you never did that you’d be writing separate programs, not one multi-threaded program.) There are two major approaches:
The approach you seem to take for granted is shared memory: except for data that has a compelling reason to be thread-specific (such as the stack), all data is accessible to all threads. Basically, there is a shared heap. That gives you speed: any time a thread changes some data, other threads can see it. (Limitation: this is not true if the threads are executing on different processors: there the programmer needs to work especially hard to use shared memory correctly and efficiently.) Most major imperative languages, in particular Java and C#, favor this model.
It is possible to have one heap per thread, plus a shared heap. This requires the programmer to decide which data to put where, and that often doesn’t mesh well with existing programming languages.
The dual approach is message passing: each thread has its own data space; when a thread wants to communicate with another thread it needs to explicitly send a message to the other thread, so as to copy the data from the sender’s heap to the recipient’s heap. In this setting many communities prefer to call the threads processes. That gives you safety: since a thread can’t overwrite some other thread’s memory on a whim, a lot of bugs are avoided. Another benefit is distribution: you can make your threads run on separate machines without having to change a single line in your program. You can find message passing libraries for most languages but integration tends to be less good. Good languages to understand message passing in are Erlang and JoCaml.
In fact message passing environments usually use shared memory behind the scene, at least as long as the threads are running on the same machine/processor. This saves a lot of time and memory since passing a message from one thread to another then doesn’t require making a copy of the data. But since the shared memory is not exposed to the programmer, its inherent complexity is confined to the language/library implementation.