多线程中用来确保同一时刻只有一个线程操作被保护的数据
InitializeCriticalSection(&cs);//初始化临界区
EnterCriticalSection(&cs);//进入临界区
//操作数据
MyMoney*=10;//所有访问MyMoney变量的程序都需要这样写Enter…
Leave…
LeaveCriticalSection(&cs);//离开临界区
DeleteCriticalSection(&cs);//删除临界区
多个线程操作相同的数据时，一般是需要按顺序访问的，否则会引导数据错乱，无法控制数据，变成随机变量。为解决这个问题，就需要引入互斥变量，让每个线程都按顺序地访问变量。这样就需要使用EnterCriticalSection和
LeaveCriticalSection函数。
比如说我们定义了一个共享资源dwTime[100]，两个线程ThreadFuncA和ThreadFuncB都对它进行读写操作。当我们想要保证 dwTime[100]的操作完整性，即不希望写到一半的数据被另一个线程读取，那么用CRITICAL_SECTION来进行线程同
步如下：
第一个线程函数：
DWORD WINAPI ThreadFuncA(LPVOID lp)
{
EnterCriticalSection(&cs);
…
//
操作dwTime
…
LeaveCriticalSection(&cs);
return
0;
}
写出这个函数之后，很多初学者都会错误地以为，此时cs对dwTime进行了锁定操作，dwTime处于cs的保护之中。一个“自然而然”的想法就是——cs和dwTime一一对应上了。
这么想，就大错特错了。dwTime并没有和任何东西对应，它仍然是任何其它线程都可以访问的。如果你像如下的方式来写第二个线程，那么就会有问题：
DWORD WINAPI ThreadFuncB(LPVOID lp)
{
...
// 操作dwTime
...
return 0;
}
当线程ThreadFuncA执行了EnterCriticalSection(&cs)，并开始操作dwTime[100]的时候，线程 ThreadFuncB可能随时醒过来，也开始操作dwTime[100]，这样，dwTime[100]中的数据就被破坏了。
为了让CRITICAL_SECTION发挥作用，我们必须在访问dwTime的任何一个地方都加上 EnterCriticalSection(&cs)和LeaveCriticalSection(&cs)语句。所以，必须按照下面的 方式来写第二个线程函数：
DWORD WINAPI ThreadFuncB(LPVOID lp)
{
EnterCriticalSection(&cs);
…
//
操作dwTime
…
LeaveCriticalSection(&cs);
return
0;
}
这样，当线程ThreadFuncB醒过来时，它遇到的第一个语句是EnterCriticalSection(&cs)，这个语句将对cs变量 进行访问。如果这个时候第一个线程仍然在操作dwTime[100]，cs变量中包含的值将告诉第二个线程，已有其它线程占用了
cs。因此，第二个线程的 EnterCriticalSection(&cs)语句将不会返回，而处于挂起等待状态。直到第一个线程执行了 LeaveCriticalSection(&cs)，第二个线程的EnterCriticalSection(&cs)语句才会返回， 并且继续执行下面的操作
。
这个过程实际上是通过限制有且只有一个函数进入CriticalSection变量来实现代码段同步的。简单地说，对于同一个 CRITICAL_SECTION，当一个线程执行了EnterCriticalSection而没有执行LeaveCriticalSection的时 候，其它任何一
个线程都无法完全执行EnterCriticalSection而不得不处于等待状态。
再次强调一次，没有任何资源被“锁定”，CRITICAL_SECTION这个东东不是针对于资源的，而是针对于不同线程间的代码段的！我们能够用它来进 行所谓资源的“锁定”，其实是因为我们在任何访问共享资源的地方都加入了
EnterCriticalSection和 LeaveCriticalSection语句，使得同一时间只能够有一个线程的代码段访问到该共享资源而已（其它想访问该资源的代码段不得不等待）。
这就是使用一个CRITICAL_SECTION时的情况。你应该要知道，它并没有什么可以同步的资源的“集合”。这个概念不正确。
如果是两个CRITICAL_SECTION，就以此类推。
***************************************************
很多人对CRITICAL_SECTION的理解是错误的，认为CRITICAL_SECTION是锁定了资源，其实，CRITICAL_SECTION是不能够“锁定”资源的，它能够完成的功能，是同步不同线程的代码段。简单说，当一个线程执行了
EnterCritialSection之后，cs里面的信息便被修改了，以指明哪一个线程占用了它。而此时，并没有任何资源被“锁定”。不管什么资源，其它线程都还是可以访问的（当然，执行的结果可能是错误的）。
只不过，在这个线程尚未执行LeaveCriticalSection之前，其它线程碰到EnterCritialSection语句的话，就会处于等待状态，相当于线程被挂起了。
这种情况下，就起到了保护共享资源的作用。
也正由于CRITICAL_SECTION是这样发挥作用的，所以，必须把每一个线程中访问共享资源的语句都放在EnterCritialSection和LeaveCriticalSection之间。这是初学者很容易忽略的地方。
当然，上面说的都是对于同一个CRITICAL_SECTION而言的。
如果用到两个CRITICAL_SECTION，比如说：
第一个线程已经执行了EnterCriticalSection(&cs)并且还没有执行LeaveCriticalSection(&cs)，这时另一个线程想要执行EnterCriticalSection(&cs2)，这种情况是可以的（除非cs2已经被第三个线程抢先占用了）。
这也就是多个
CRITICAL_SECTION实现同步的思想。
比如说我们定义了一个共享资源dwTime[100]，两个线程ThreadFuncA和ThreadFuncB都对它进行读写操作。当我们想要保证dwTime[100]的操作完整性，即不希望写到一半的数据被另一个线程读取，那么用CRITICAL_SECTION来进行
线程同步如下：
第一个线程函数：
DWORD WINAPI ThreadFuncA(LPVOID lp)
{
EnterCriticalSection(&cs);
…
//
操作dwTime
…
LeaveCriticalSection(&cs);
return
0;
}
写出这个函数之后，很多初学者都会错误地以为，此时cs对dwTime进行了锁定操作，dwTime处于cs的保护之中。一个“自然而然”的想法就是——cs和dwTime一一对应上了。
这么想，就大错特错了。dwTime并没有和任何东西对应，它仍然是任何其它线程都可以访问的。
如果你像如下的方式来写第二个线程，那么就会有问题：
DWORD WINAPI ThreadFuncB(LPVOID lp)
{
...
// 操作dwTime
...
return 0;
}
当线程ThreadFuncA执行了EnterCriticalSection(&cs)，并开始操作dwTime[100]的时候，线程ThreadFuncB可能随时醒过来，也开始操作dwTime[100]，
这样，dwTime[100]中的数据就被破坏了。
为了让CRITICAL_SECTION发挥作用，我们必须在访问dwTime的任何一个地方都加上EnterCriticalSection(&cs)和LeaveCriticalSection(&cs)语句。
所以，必须按照下面的方式来写第二个线程函数：
DWORD
WINAPI
ThreadFuncB(LPVOID
lp)
{
EnterCriticalSection(&cs);
…
//
操作dwTime
…
LeaveCriticalSection(&cs);
return
0;
}
这样，当线程ThreadFuncB醒过来时，它遇到的第一个语句是EnterCriticalSection(&cs)，这个语句将对cs变量进行访问。
如果这个时候第一个线程仍然在操作dwTime[100]，cs变量中包含的值将告诉第二个线程，已有其它线程占用了cs。
因此，第二个线程的EnterCriticalSection(&cs)语句将不会返回，而处于挂起等待状态。直到第一个线程执行了LeaveCriticalSection(&cs)，
第二个线程的EnterCriticalSection(&cs)语句才会返回，并且继续执行下面的操作。
这个过程实际上是通过限制有且只有一个函数进入CriticalSection变量来实现代码段同步的。简单地说，对于同一个CRITICAL_SECTION，
当一个线程执行了EnterCriticalSection而没有执行LeaveCriticalSection的时候，其它任何一个线程都无法完全执行EnterCriticalSection而不得不处于等待状态。
再次强调一次，没有任何资源被“锁定”，CRITICAL_SECTION这个东东不是针对于资源的，而是针对于不同线程间的代码段的！我们能够用它来进行所谓资源的“锁定”，
其实是因为我们在任何访问共享资源的地方都加入了EnterCriticalSection和LeaveCriticalSection语句，
使得同一时间只能够有一个线程的代码段访问到该共享资源而已（其它想访问该资源的代码段不得不等待）。
如果是两个CRITICAL_SECTION，就以此类推。
再举个极端的例子，可以帮助你理解CRITICAL_SECTION这个东东：
第一个线程函数：
DWORD WINAPI ThreadFuncA(LPVOID lp)
{
EnterCriticalSection(&cs);
for(int i=0;i
<1000;i++)
Sleep(1000);
LeaveCriticalSection(&cs);
return
0;
}
第二个线程函数：
DWORD WINAPI ThreadFuncB(LPVOID lp)
{
EnterCriticalSection(&cs);
index=2;
LeaveCriticalSection(&cs);
return
0;
}
这种情况下，第一个线程中间总共Sleep了1000秒钟！它显然没有对任何资源进行什么“有意识”的保护；而第二个线程是要访问资源index的，
但是由于第一个线程占用了cs，一直没有Leave，而导致第二个线程不得不登上1000秒钟……
第二个线程，真是可怜哪。。。
这个应该很说明问题了，你会看到第二个线程在1000秒钟之后开始执行index=2这个语句。
也就是说，CRITICAL_SECTION其实并不理会你关心的具体共享资源，它只按照自己的规律办事~
