Relation between Thread ID and Process ID

Question

I am having some confusion between Process Id and Thread Id. I have gone through several web-post including stack overflow here, Which says

starting a new process gives you a new PID and a new TGID, while starting a new thread gives you a new PID while maintaining the same TGID.

So when I run a program why all the threads created from the program don't have different PID?

I know in programming we usually say that the main is a thread and execution starts from main , So if I create multiple thread from main, all the threads will have the same PID which is equal to the main's PID.

So what I wanted to ask is as below:

1) When we run a program it will run as a process or a thread?

2) Is there any difference between main thread creating threads and Process creating threads?

3) Is there any difference between thread and process in linux? Since I read somewhere that linux doesn't differentiate between Thread and Process.

Answer 1

I got the answer here on stackoverflow. It states that if we run a program on Linux that contains the libc libuClibc-0.9.30.1.so (1). Basically an older version of libc then thread created will have different PID as shown below

root@OpenWrt:~# ./test
main thread pid is 1151
child thread pid is 1153

and I tried to run this program with a linux that contains the libc from ubuntu libc6 (2) i.e newer version of libc then Thread created will have the same PID as the process.

$ ./test
main thread pid is 2609
child thread pid is 2609
The libc (1) use linuxthreads implementation of pthread

And the libc (2) use NPTL ("Native posix thread library") implementation of pthread

According to the linuxthreads FAQ (in J.3 answer):

each thread is really a distinct process with a distinct PID, and signals sent to the PID of a thread can only be handled by that thread

So in the old libc which use linuxthreads implementation, each thread has its distinct PID

In the new libc version which use NPTL implementation, all threads has the same PID of the main process.

The NPTL was developed by redhat team. and according to the redhat NPTL document: One of the problems which are solved in the NPTL implementation is:

(Chapter: Problems with the Existing Implementation, page5)

Each thread having a different process ID causes compatibility problems with other POSIX thread implementations. This is in part a moot point since signals can't be used very well but is still noticeable

And that explain this issue.

I am using the new libc version that contains the NPTL ("Native posix thread library") implementation of pthread.

Answer 2

This confusion comes from the Linux concept of tasks.

In Linux there is little difference between a task and a thread though.

Every process is a self contained VM running at least one task.

Each task is an independent execution unit within a process scope.

The main task of a process gives it's task id (TID) to the process as it's process id (PID).

Every new thread that you spawn within a process creates a new task within it. In order to identify then individually in the kernel they get assigned their own individual task id (TID).

All tasks within a process share the same task group id (TGID).

Answer 3

The post you have shown describes of Linux threading implementation which I suppose is the older version of Linux implementation where threads were created as a different process. In the POSIX implementation of threads, the threads are not created as a different process rather they create different streams of parallel execution of the code which have some components differ in the those parallel execution, the information of which is stored by Thread Descriptor storing the TID. Whereas the process creating multiple thread can be referred as a multi-threaded process, thus has a same PID of all its thread but different TID's. The main process creating thread can be referred as Main thread

Answer 4

You will get same Process ID as all threads are sharing your program data which is your process so when you call for Process ID you get the same.

Answer 5

Simplifying a bit:

1. The PID is the process ID, TID is the thread ID. The thing is that for the first thread created by fork(), PID=TID. If you create more threads within the process, with a clone() command, then PID and TID will be different, PID will always be smaller than TID.

2. No, there is no difference, except maybe that if main is killed, all other threads are also killed.

3. Yes, the thread is what actually gets scheduled. Technically, the process is only a memory mapping of the different segments of code (text, bss, stack, heap and the OS).