多线程编程--5种方法实现线程同步
1：用Interlocked系列函数实现线程同步；
2：用CRITICAL_SECTION及其系列函数实现线程同步； 3：用RTL_SRWLOCK及其系列函数实现线程同步； 4：用事件内核对象实现线程同步； 5：用信号量内核对象实现线程同步；
1：用Interlocked系列函数实现线程同步实例如下：
//旋转锁
#include using namespace std; #include #include const int threadNum=10; HANDLE hThread[threadNum]; volatile unsigned int ISOK=0; unsigned int _stdcall Interlocked(PVOID threadId { while(InterlockedExchange(&ISOK,1==1 ; cout<<"线程："<<*(int*threadId<<"开始"< Sleep(100; cout<<"线程："<<*(int*threadId<<"结束"< InterlockedExchange(&ISOK,0; return 0; } void InterlockedTest( { int threadId[threadNum]; for(int i=0;i { threadId[i]=i+1; } cout<<"1：用Interlocked系列函数实现线程同步"< for(int i=0;i<10;i++{ hThread[i]=(HANDLE_beginthreadex(NULL, 0, Interlocked,threadId+i, 0, NULL; } WaitForMultipleObjects(threadNum, hThread, TRUE, INFINITE; for(int i=0;i { CloseHandle(hThread[i]; } }
InterlockedExchange确保以原子的方式操作数据。执行速度非常快，缺点是如果要同步的部分执行的时间比较长的话，while循环会一直轮询操作，浪费CPU的时间，在单核CPU的系统中，可能会出现while一直暂用CPU导致其他线程不能修改ISOK的值，导致不能跳出while循环，出现死循环。还有就是线程的优先级问题也能导致问题。 2：用CRITICAL_SECTION及其系列函数实现线程同步实例如下：
//关键段 #include using namespace std; #include #include const int threadNum=10; HANDLE hThread[threadNum]; CRITICAL_SECTION g_cs;//构造一个CRITICAL_SECTION实例 unsigned int _stdcall CriticalSection(PVOID threadId { EnterCriticalSection(&g_cs;//进入关键段
cout<<"线程："<<*(int*threadId<<"开始"< Sleep(100;
cout<<"线程："<<*(int*threadId<<"结束"< LeaveCriticalSection(&g_cs;//进入关键段 return 0; }
void CriticalSectionTest( { int threadId[threadNum]; for(int i=0;i { threadId[i]=i+1; } InitializeCriticalSection(&g_cs;//初始化g_cs的成员 cout<<"2：用CRITICAL_SECTION及其系列函数实现线程同步"< for(int i=0;i<10;i++{ hThread[i]=(HANDLE_beginthreadex(NULL, 0, CriticalSection,threadId+i, 0, NULL; } WaitForMultipleObjects(threadNum, hThread, TRUE, INFINITE; for(int i=0;i { CloseHandle(hThread[i]; } DeleteCriticalSection(&g_cs;//删除关键段
}
CRITICAL_SECTION同样是以原子的方式操作数据，也只有以原子的方式操作数据才能实现线程的同步，所有实现线程同步的方法，最核心的部分就是以原子的方式操作数据，CRITICAL_SECTION执行的速度非常快，其内部有一个事件内核对象，当出现资源争夺的时候，才会出现初始化这个事件内核对象，由于CRITICAL_SECTION执行非常快可能不会出现资源争夺，也就没有必要创建这个事件内核对象，这个事件内核对象创建后，会将当前线程之外的线程挂起，并记录这些线程需要这个资源，其他线程就不会浪费CPU的时间，而这些被挂起的线程将由用户模式变成内核模式，当这些线程需要的资源可用时，系统会将其中一个线程唤醒。
还有一点值得注意：如果要同步的代码执行得很快，在出现争夺资源的时候，系统把其他线程挂起，而当前线程又马上执行完成了，系统又将挂起的线程唤醒，这个过程是非常浪费CPU的，也影响程序的性能，为了避免这种情况，可以结合旋转锁和CRITICAL_SECTION，先用旋转锁轮询一定次数，还不能获得资源，再将线程挂起，等待资源被释放，系统再将线程唤醒，实现这一功能的就是方法 InitializeCriticalSectionAndSpinCount( LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount//旋转锁轮询的次数
; 除了初始化CRITICAL_SECTION用的是方法InitializeCriticalSectionAndSpinCount，而不是方法InitializeCriticalSection，其他的都是一样的。
3：用RTL_SRWLOCK及其系列函数实现线程同步实例如下：
//读写锁 #include using namespace std; #include #include const int threadNum=10; HANDLE hThread[threadNum]; RTL_SRWLOCK lock;//构造一个CRITICAL_SECTION实例 unsigned int _stdcall SrwLock(PVOID threadId { AcquireSRWLockExclusive(&lock;//进入读写锁 cout<<"线程："<<*(int*threadId<<"开始"< Sleep(100; cout<<"线程："<<*(int*threadId<<"结束"< ReleaseSRWLockExclusive(&lock;//进入读写锁 return 0; } void SrwLockTest( { int threadId[threadNum]; for(int i=0;i { threadId[i]=i+1; } InitializeSRWLock(&lock;//初始化lock的成员 cout<<"3：用RTL_SRWLOCK及其系列函数实现线程同步"< for(int i=0;i<10;i++{ hThread[i]=(HANDLE_beginthreadex(NULL, 0, SrwLock,threadId+i, 0, NULL; } WaitForMultipleObjects(threadNum, hThread, TRUE, INFINITE; for(int i=0;i { CloseHandle(hThread[i]; } }
SRWLock的目的和关键段是一样的，就是对资源的保护，不让其他线程访问。不同的是，它区分线程是读线程还是写线程。我们都是知道， 