What resources are shared between threads? – Dev

The best answers to the question “What resources are shared between threads?” in the category Dev.


Recently, I have been asked a question in an interview what’s the difference between a process and a thread. Really, I did not know the answer. I thought for a minute and gave a very weird answer.

Threads share the same memory, processes do not. After answering this, the interviewer gave me an evil smile and fired the following questions at me:

Q. Do you know the segments in which a program gets divided?

My answer: yep (thought it was an easy one) Stack, Data, Code, Heap

Q. So, tell me: which segments do threads share?

I could not answer this and ended up in saying all of them.

Please, can anybody present the correct and impressive answers for the difference between a process and a thread?


From Wikipedia (I think that would make a really good answer for the interviewer :P)

Threads differ from traditional
multitasking operating system
processes in that:

  • processes are typically independent, while threads exist as subsets of a
  • processes carry considerable state information, whereas multiple threads
    within a process share state as well
    as memory and other resources
  • processes have separate address spaces, whereas threads share their
    address space
  • processes interact only through system-provided inter-process
    communication mechanisms.
  • Context switching between threads in the same process is typically faster
    than context switching between


You’re pretty much correct, but threads share all segments except the stack. Threads have independent call stacks, however the memory in other thread stacks is still accessible and in theory you could hold a pointer to memory in some other thread’s local stack frame (though you probably should find a better place to put that memory!).


Tell the interviewer that it depends entirely on the implementation of the OS.

Take Windows x86 for example. There are only 2 segments [1], Code and Data. And they’re both mapped to the whole 2GB (linear, user) address space. Base=0, Limit=2GB. They would’ve made one but x86 doesn’t allow a segment to be both Read/Write and Execute. So they made two, and set CS to point to the code descriptor, and the rest (DS, ES, SS, etc) to point to the other [2]. But both point to the same stuff!

The person interviewing you had made a hidden assumption that he/she did not state, and that is a stupid trick to pull.

So regarding

Q. So tell me which segment thread

The segments are irrelevant to the question, at least on Windows. Threads share the whole address space. There is only 1 stack segment, SS, and it points to the exact same stuff that DS, ES, and CS do [2]. I.e. the whole bloody user space. 0-2GB. Of course, that doesn’t mean threads only have 1 stack. Naturally each has its own stack, but x86 segments are not used for this purpose.

Maybe *nix does something different. Who knows. The premise the question was based on was broken.

  1. At least for user space.
  2. From ntsd notepad: cs=001b ss=0023 ds=0023 es=0023


Something that really needs to be pointed out is that there are really two aspects to this question – the theoretical aspect and the implementations aspect.

First, let’s look at the theoretical aspect. You need to understand what a process is conceptually to understand the difference between a process and a thread and what’s shared between them.

We have the following from section 2.2.2 The Classical Thread Model in Modern Operating Systems 3e by Tanenbaum:

The process model is based on two independent concepts: resource
grouping and execution. Sometimes it is use­ful to separate them;
this is where threads come in….

He continues:

One way of looking at a process is that it is a way to
group related resources together. A process has an address space
containing program text and data, as well as other resources. These
resource may include open files, child processes, pending alarms,
signal handlers, accounting information, and more. By putting them
together in the form of a process, they can be managed more easily.
The other concept a process has is a thread of execution, usually
shortened to just thread. The thread has a program counter that keeps
track of which instruc­tion to execute next. It has registers, which
hold its current working variables. It has a stack, which contains the
execution history, with one frame for each proce­dure called but not
yet returned from. Although a thread must execute in some process, the
thread and its process are different concepts and can be treated
sepa­rately. Processes are used to group resources together; threads
are the entities scheduled for execution on the CPU.

Further down he provides the following table:

Per process items             | Per thread items
Address space                 | Program counter
Global variables              | Registers
Open files                    | Stack
Child processes               | State
Pending alarms                |
Signals and signal handlers   |
Accounting information        |

The above is what you need for threads to work. As others have pointed out, things like segments are OS dependant implementation details.