thread-shared environments include the process code snippet, the public data of the process (which leverages the shared data, the threads are easily communicating with each other), the file descriptor that the process opens, the processor of the signal, the current directory of the process, and the process user ID and process group ID. The process has its own personality as well as its many commonalities. With these personalities, threads can achieve concurrency. Shared resources: A. Heap because the heap is opened up in the process space, it is rightfully shared; so new is shared (16-bit platform on the global heap and local heap, local heap is exclusive) b. Global variables it is not related to a specific function, so it is not related to a particular thread And therefore also shared C. Static variables although for local variables, it is "put" in a function in the code, but its location and global variables, the same as in the heap open. BSS and. Data segments, which are shared d. Files and other common resources this is shared, Threads that use these common resources must be synchronized. WIN32 provides several ways to synchronize resources, including signals, critical sections, events, and mutexes. The exclusive resources are
Unique resources: 1. Thread ID
Each thread has its own thread ID, which is unique in this process. The process uses this to identify the thread. 2. Value of the Register group
Because the threads are running concurrently, each thread has its own different running threads, and when switching from one thread to another, the state of the Register collection of the original thread must be saved so that the thread can be restored in the future when it is re-switched to. 3. The stack of threads
The stack is necessary to ensure that the thread runs independently. A thread function can call a function, and the called function can be nested in layers, so the thread must have its own stack of functions so that the function call can execute normally, not affected by other threads.
4. Error return code
Since many threads in the same process are running concurrently, it is possible for a thread to set the errno value after a system call, while the thread has not handled the error and another thread is running at this point by the scheduler, so that the error value can be modified. Therefore, different threads should have their own error return code variable.
5. Thread's Signal Shield code
Because each thread is interested in a different signal, the thread's signal masking code should be managed by the thread itself. But all the threads share the same signal processor.
6. Priority of Threads
Because the thread needs to be dispatched like a process, there must be a parameter available for dispatch, which is the thread's priority.
A. Stack: one per thread, this undoubtedly asks
B. Data section: Only read-only data segments can be shared, read-write once written once, will not be shared
C. Register set: Each thread has to save its own context, and the thread will revert to the hardware register when it is cut in, and the thread should be saved
D. File FD: Common resources such as files
E.threadid: One per thread, this undoubtedly asks
