Yards farm charging station--process and thread
A process is a container, not an execution entity, and a thread is an executing entity.
The process consists of two parts,
1, the kernel object, the essence is a data structure, by the operating system management
2, DLLs and actuators (including heap, stack, code snippet)
Under 32-bit platforms, each process has 4GB of virtual memory.
Due to the opening and loading of the process, the operating system must switch the context, so the consumption of resources is relatively large.
Multiple threads of the same process are shared resources.
So the preferred is to use multithreading instead of multiple processes.
The thread consists of two parts;
1, the kernel object, the essence is a data structure, by the operating system management
2. Thread's own stack
There are two types of Windows platform online
Worker thread interface thread
The two are not much different in nature, just the worker thread does not have a message loop
Because static variables and global variables are placed in the memory static zone
Parsing from a compilation perspective is a data segment that is independent of the code snippet and allocates memory at compile time
That way , multiple threads share these resources. Which means that multiple threads can access both static and global variables
Therefore, you should pay attention to thread safety when accessing static and global variables in multiple threads.
There are several ways to troubleshoot thread safety issues:
Thread synchronization implementations have mutexes, event objects, key code snippets
Mutexes and Event objects belong to kernel objects that are managed directly by the operating system
More complex to use more resources
The key code snippet is the user object
Simple to use with less resources
But it's easy to cause thread deadlock
Note the thread deadlock problem when another key code is included in the key code snippet
As follows:
Thread 1 owns object a preemption object B
Thread 2 owns object b preemption Object A
One example is a good description of thread deadlock issues:
Philosophers Dine
3 Philosophers of ethyl C dined at the same time, but each had only one chopstick. So everyone can't eat.
If one of the philosophers handed out his chopsticks to two other philosophers, such as to B, then B would be able to dine.
b after eating a little, the chopsticks handed out to C, and then take turns to use. Can solve the problem of eating.
But these philosophers are more selfish and stubborn, and no one is allowed to cause deadlocks.
Reading, practicing, thinking, summarizing
Reprint Please specify source: http://www.cnblogs.com/zhuojun/
Yards farm charging station--process and thread