If threads share the same PID, how can they be identified?

by

The four threads will have the same PID but only when viewed from above. What you (as a user) calls a PID is not what the kernel (looking from below) calls a PID.

In the kernel, each thread has its own ID, called a PID, although it would possibly make more sense to call this a TID, or thread ID, and they also have a TGID (thread group ID) which is the PID of the first thread that was created when the process was created.

When a new process is created, it appears as a thread where both the PID and TGID are the same (currently unused) number.

When a thread starts another thread, that new thread gets its own PID (so the scheduler can schedule it independently) but it inherits the TGID from the original thread.

That way, the kernel can happily schedule threads independent of what process they belong to, while processes (thread group IDs) are reported to you.

The following hierarchy of threads may help(a):

                         USER VIEW
                         vvvv vvvv
              |          
<-- PID 43 -->|<----------------- PID 42 ----------------->
              |                           |
              |      +---------+          |
              |      | process |          |
              |     _| pid=42  |_         |
         __(fork) _/ | tgid=42 | \_ (new thread) _
        /     |      +---------+          |       \
+---------+   |                           |    +---------+
| process |   |                           |    | process |
| pid=43  |   |                           |    | pid=44  |
| tgid=43 |   |                           |    | tgid=42 |
+---------+   |                           |    +---------+
              |                           |
<-- PID 43 -->|<--------- PID 42 -------->|<--- PID 44 --->
              |                           |
                        ^^^^^^ ^^^^
                        KERNEL VIEW

You can see that starting a new process (on the left) gives you a new PID and a new TGID (both set to the same value). Starting a new thread (on the right) gives you a new PID while maintaining the same TGID as the thread that started it.

(a) Tremble in awe at my impressive graphical skills 🙂

More Related Contents:

  1. What is a race condition?
  2. How can I pass a reference to a stack variable to a thread?
  3. How to run a background task in a servlet based web application?
  4. How many threads is too many?
  5. How to create threads in nodejs
  6. How to avoid Not on FX application thread; currentThread = JavaFX Application Thread error?
  7. What is a semaphore?
  8. how to set CPU affinity of a particular pthread?
  9. What does threadsafe mean?
  10. What resources are shared between threads?
  11. How to articulate the difference between asynchronous and parallel programming?
  12. Technically, why are processes in Erlang more efficient than OS threads?
  13. What is a deadlock?
  14. How many memory barriers instructions does an x86 CPU have?
  15. Simple Thread Sample Delphi
  16. To use thread in programming in vb6
  17. How would you define a pool of goroutines to be executed at once?
  18. How to share data between threads in this threaded TCPServer?
  19. How JavaFX application thread works?
  20. Is non-blocking I/O really faster than multi-threaded blocking I/O? How?
  21. Python 2.7: streaming HTTP server supporting multiple connections on one port
  22. Are “data races” and “race condition” actually the same thing in context of concurrent programming
  23. When is a condition variable needed, isn’t a mutex enough?
  24. How are user-level threads scheduled/created, and how are kernel level threads created?
  25. JavaFX working with threads and GUI
  26. Difference between user-level and kernel-supported threads?
  27. How do I run parallel threads of computation on a partitioned array?
  28. Can we have race conditions in a single-thread program?
  29. Does multi-threading improve performance? How?
  30. Thread-safe in delphi

Leave a Comment