博客
关于我
强烈建议你试试无所不能的chatGPT，快点击我
Windows线程同步API
阅读量：6543 次
发布时间：2019-06-24

本文共 12013 字，大约阅读时间需要 40 分钟。

本文主要总结创建、结束线程和WIN32 API提供的一些线程同步方法。同步方法包括用户态同步方式：InterLock、CriticalSection、SRWLock和内核态同步方式：Event、Semaphore、Mutex等。本文通过简单的例子演示API的使用，没有包含原理的说明，假定读者具有其他语言或者平台的并发编程经验。

创建、结束线程

WIN32 API虽然提供了CreateThead和ExitThread方法，但是在C++中，永远不应该使用这两个方法创建或结束线程。而应该使用VC++提供的_beginthread、_beginthreadex方法，相应的结束线程方法_endthread、_endthreadex。后者除了在内部调用CreateThread或ExitThread方法外，还负责CRT的初始化或销毁。虽然有直接结束线程的方法，但在C++最好通过线程方法正常返回来结束线程。直接结束线程时C++对象的析构函数不会被调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include "stdafx.h"
  
using
namespace
std;
  
class
Obj
{
public
:
    
Obj() { cout <<
"Obj() called"
<< endl; }
    
~Obj() { cout <<
"~Obj() called"
<< endl; }
};
  
unsigned
int
WINAPI ThreadFunc(
void
* pvParam){
    
cout <<
static_cast
<
char
*>(pvParam) << endl;
    
Obj obj;
    
_endthreadex(2);
    
return
1;
}
  
int
_tmain(
int
argc, _TCHAR* argv[])
{
    
unsigned
int
threadId;
    
char
*param =
"param"
;
    
HANDLE
thread
= (
HANDLE
)_beginthreadex(NULL, 0, ThreadFunc, param, 0, &threadId);
  
    
Sleep(100);
    
DWORD
exitCode;
    
GetExitCodeThread(
thread
, &exitCode);
    
cout <<
"ExitCode:"
<< exitCode << endl;
    
system
(
"pause"
);
    
return
0;
}

这段代码的输出为：

param

Obj() called
ExitCode:2
请按任意键继续. . .

_beginthreadex的第一个参数为SECURITY_ATTRIBUTES结构指针，可以指定NULL使用默认的安全配置。第二参数为cbStackSize，线程栈大小；设置为0使用默认值，可以通过链接参数/STACK:[reserve][,commit]控制。第三个参数为线程入口方法地址，方法签名如ThreadFunc所示。第四个三处为传递给入口方法的参数（值传递），具体意义由程序自己解释。最后一个参数是返回的线程ID。返回值为新创建线程的句柄。__endthreadex方法唯一的参数指定线程的ExitCode。可以通过GetExitCodeThread方法获得线程退出码。

InterLocked系列原子方法

InterLocked系列方法可视为原子的。完成其功能时，保证其他线程不会访问同一个资源。例如最简单的InterLockedIncrement方法原子自增一个共享变量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
long
g_sum(0);
  
unsigned
int
WINAPI ThreadFunc(
void
* pvParam){
    
for
(
int
i = 0; i < 100000; ++i)
    
{
        
InterlockedIncrement(&g_sum);
    
}
    
return
0;
}
  
int
_tmain(
int
argc, _TCHAR* argv[])
{
    
unsigned
int
threadId;
    
HANDLE
thread1 = (
HANDLE
)_beginthreadex(NULL, 0, ThreadFunc, NULL, 0, &threadId);
    
HANDLE
thread2 = (
HANDLE
)_beginthreadex(NULL, 0, ThreadFunc, NULL, 0, &threadId);
  
    
Sleep(1000);
    
cout <<
"Sum:"
<< g_sum << endl;
    
system
(
"pause"
);
    
return
0;
}

其他方法包括：

InterlockedIncrement64：自增一个64位整数。

InterlockedExchangeAdd、InterlockedExchangeAdd64：加和两个数并赋值给第一个值。

InterlockedCompareExchange：比较并交换一个数。

还有很多InterLocked方法，具体参考MSDN文档。

CriticalSection

通过EnterCriticalSection和LeaveCriticalSection方法，可以控制同步一段代码的访问。使用前需要使用InitializeCriticalSection初始化CRITICAL_SECTION。使用方法也很简单。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
CRITICAL_SECTION g_cs;
long
g_sum(0);
  
unsigned
int
WINAPI ThreadFunc(
void
* pvParam){
    
for
(
int
i = 0; i < 100000; ++i)
    
{
        
EnterCriticalSection(&g_cs);
        
g_sum += 2;
        
LeaveCriticalSection(&g_cs);
    
}
    
return
0;
}
  
int
_tmain(
int
argc, _TCHAR* argv[])
{
    
InitializeCriticalSection(&g_cs);
    
unsigned
int
threadId;
    
HANDLE
thread1 = (
HANDLE
)_beginthreadex(NULL, 0, ThreadFunc, NULL, 0, &threadId);
    
HANDLE
thread2 = (
HANDLE
)_beginthreadex(NULL, 0, ThreadFunc, NULL, 0, &threadId);
  
    
Sleep(1000);
    
cout <<
"Sum:"
<< g_sum << endl;
    
DeleteCriticalSection(&g_cs);
    
system
(
"pause"
);
    
return
0;
}

这里有一个问题是，如果同步的代码块不是简单g_sum += 2，而是可能抛出异常的复杂代码。就需要确保LeaveCriticalSection一定被调用。不再使用后使用DeleteCriticalSection方法删除之。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class
CSManager
{
public
:
    
CSManager(CRITICAL_SECTION *cs) : m_cs(cs)
    
{
        
EnterCriticalSection(m_cs);
    
}
    
~CSManager()
    
{
        
LeaveCriticalSection(m_cs);
    
}
private
:
    
CRITICAL_SECTION *m_cs;
};
  
//...
    
for
(
int
i = 0; i < 100000; ++i)
    
{
        
CSManager CSMgr(&g_cs);
        
g_sum += 2;
    
}
//...

CSManager在构造函数中调用EnterCriticalSection，析构函数中调用LeaveCriticalSection。保证在代码块结束时调用Leave方法。

另外除了使用阻塞的Enter方法，还有一个TryEnterCriticalSection，该方法尝试进去CriticalSetion，如果失败，不会阻塞，而是立即返回FALSE。

SRWLOCK

SRWLOCK具有和CriticalSection类似的功能。另外还具有读写锁分离的分离的功能。可以使用AcquireSRWLockShared获取共享的读锁。使用AcquireSRWLockExclusive获取独占的写锁。使用对应的ReleaseSRWLockShared/Exclusive方法施放锁。同样地，使用前需要使用InitializeSRWLock初始化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
SRWLOCK g_lock;
long
g_sum(0);
  
unsigned
int
WINAPI ReadThreadFunc(
void
* pvParam){
    
for
(
int
i = 0; i < 10; ++i)
    
{
        
AcquireSRWLockShared(&g_lock);
        
cout << g_sum << endl;
        
ReleaseSRWLockShared(&g_lock);
        
Sleep(1);
    
}
    
return
0;
}
  
unsigned
int
WINAPI WriteThreadFunc(
void
* pvParam){
    
for
(
int
i = 0; i < 100000; ++i)
    
{
        
AcquireSRWLockExclusive(&g_lock);
        
g_sum += 2;
        
ReleaseSRWLockExclusive(&g_lock);
    
}
    
return
0;
}
  
int
_tmain(
int
argc, _TCHAR* argv[])
{
    
InitializeSRWLock(&g_lock);
  
    
unsigned
int
threadId;
    
HANDLE
thread1 = (
HANDLE
)_beginthreadex(NULL, 0, ReadThreadFunc, NULL, 0, &threadId);
    
HANDLE
thread2 = (
HANDLE
)_beginthreadex(NULL, 0, ReadThreadFunc, NULL, 0, &threadId);
    
HANDLE
thread3 = (
HANDLE
)_beginthreadex(NULL, 0, WriteThreadFunc, NULL, 0, &threadId);
  
    
Sleep(1000);
    
cout <<
"Sum:"
<< g_sum << endl;
    
system
(
"pause"
);
    
return
0;
}

SRWLOCK不具备类似于TryEnterCriticalSection的非阻塞方法。大多数情况下，SRWLOCK比CRITICAL_SECTION有更好的性能。

Condition Variable

为实现近点的生产者消费者问题。我们可以使用两个CONDITION_VARIABLE：g_full，g_empty来实现。在缓冲区满的时候，生产者线程调用SleepConditionVariableSRW(&g_full, &g_lock, INFINITE, 0)施放获得的锁并等待g_full。缓冲区空的时候，消费者可以调用leepConditionVariableSRW(&g_empty, &g_lock, INFINITE, 0)施放获得的锁并等待g_empty。掉进满足后，可是使用WakeAllConditionVariable唤醒所有等待的线程或者使用WakeConditionVariable唤醒一个等待的线程。

和Condition Variable配置使用的可以使CrticalSection也可以使SRWLock。

1
2
3
4
5
6
7
8
9
10
BOOL
SleepConditionVariableCS(
   
PCONDITION_VARIABLE pConditionVariable,
   
PCRITICAL_SECTION pCriticalSection,
   
DWORD
dwMilliseconds);
  
BOOL
SleepConditionVariableSRW(
   
PCONDITION_VARIABLE pConditionVariable,
   
PSRWLOCK pSRWLock,
   
DWORD
dwMilliseconds,
   
ULONG
Flags);

参数dwMilliseconds指定等待超时的时间，如果超时方法返回FASLE；INFINITE指定等待不超时。参数Flags指定被唤醒时尝试获得的锁的类型。CONDITION_VARIABLE_LOCKMODE_ SHARED指定获得共享锁或者0指定获得独占锁。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
const
int
MAX_SIZE = 10;
  
CONDITION_VARIABLE g_full;
CONDITION_VARIABLE g_empty;
SRWLOCK g_lock;
  
list<Product> products;
  
unsigned
int
WINAPI ProduceThreadFunc(
void
* pvParam)
{
    
int
i(0);
    
while
(
true
)
    
{
        
Sleep(
rand
() % 100);
        
AcquireSRWLockExclusive(&g_lock);
  
        
if
(products.size() >= MAX_SIZE)
        
{
            
SleepConditionVariableSRW(&g_full, &g_lock, INFINITE, 0);
        
}
        
else
        
{
            
cout <<
"Produce Product:"
<< i <<
" by thread "
<< GetThreadId(GetCurrentThread()) << endl;
            
products.push_back(Product(i++));
        
}
  
        
WakeAllConditionVariable(&g_empty);
        
ReleaseSRWLockExclusive(&g_lock);
          
    
}
    
return
0;
}
  
unsigned
int
WINAPI ConsumeThreadFunc(
void
* pvParam)
{
    
while
(
true
)
    
{
        
Sleep(
rand
() % 100);
  
        
AcquireSRWLockExclusive(&g_lock);
        
if
(products.size() == 0)
        
{
            
SleepConditionVariableSRW(&g_empty, &g_lock, INFINITE, 0);
        
}
        
else
        
{
            
Product p = products.front();
            
products.pop_front();
            
cout <<
"Consume Product:"
<< p.m_no <<
" by thread "
<< GetThreadId(GetCurrentThread()) << endl;
        
}
  
        
WakeAllConditionVariable(&g_full);
        
ReleaseSRWLockExclusive(&g_lock);
          
  
    
}
    
return
0;
}
  
int
_tmain(
int
argc, _TCHAR* argv[])
{
    
srand
((unsigned)
time
(NULL));
    
InitializeSRWLock(&g_lock);
    
unsigned
int
threadId;
    
HANDLE
thread1 = (
HANDLE
)_beginthreadex(NULL, 0, ProduceThreadFunc, NULL, 0, &threadId);
    
HANDLE
thread2 = (
HANDLE
)_beginthreadex(NULL, 0, ConsumeThreadFunc, NULL, 0, &threadId);
    
HANDLE
thread3 = (
HANDLE
)_beginthreadex(NULL, 0, ConsumeThreadFunc, NULL, 0, &threadId);
  
    
WaitForSingleObject(thread1, INFINITE);
    
WaitForSingleObject(thread2, INFINITE);
    
WaitForSingleObject(thread3, INFINITE);
    
system
(
"pause"
);
    
return
0;
}

内核态线程同步方法

除了上面介绍的用户态的线程同步方法。本文继续通过几个简单例子演示内核态的线程同步方法的使用。内核态线程同步方法在性能上肯定比用户态同步方法要差很多。但可以在多个进程间共享。

创建所有的内核态同步对象都范围一个内核对象句柄HANDLE。通过WaitForSingleObject或者WaitForMultipleObjects等待内核同步对象转换为已传信状态（signaled）。如果等待的是线程或者进程对象，那么对应线程或进程结束后即转换为已传信状态。同时还可以指定一个超时时间。WaitForSingleObject包括WAIT_OBJECT_0，WAIT_TIMEOUT和WAIT_FAILED。不再使用后调用CloseHandle释放引用。

1
2
3
4
5
6
7
8
9
10
11
12
DWORD
dw = WaitForSingleObject(hProcess, 5000);
switch
(dw) {
   
case
WAIT_OBJECT_0:
     
// The process terminated.
     
break
;
   
case
WAIT_TIMEOUT:
      
// The process did not terminate within 5000 milliseconds.
      
break
;
   
case
WAIT_FAILED:
      
// Bad call to function (invalid handle?)
      
break
;
}

WaitForMultipleObjects如果指定参数bWaitAll为TRUE，则等待所有对象都转换为已传信状态后才返回，如果为指定bWaitAll为FALSE，则任意对象转换为已传信状态即返回。可以通过以下方法来判断是那个内核同步对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
h[0] = hProcess1;
h[1] = hProcess2;
h[2] = hProcess3;
DWORD
dw = WaitForMultipleObjects(3, h, FALSE, 5000);
switch
(dw) {
   
case
WAIT_FAILED:
      
// Bad call to function (invalid handle?)
      
break
;
  
   
case
WAIT_TIMEOUT:
      
// None of the objects became signaled within 5000 milliseconds.
      
break
;
  
   
case
WAIT_OBJECT_0 + 0:
      
// The process identified by h[0] (hProcess1) terminated.
      
break
;
  
   
case
WAIT_OBJECT_0 + 1:
      
// The process identified by h[1] (hProcess2) terminated.
      
break
;
  
   
case
WAIT_OBJECT_0 + 2:
      
// The process identified by h[2] (hProcess3) terminated.
      
break
;
}

Event

Event语义上可以理解为一个事件是否发生。SetEvent方法设置Event为Signaled状态。Event有两种类型。第一种是自动重置的事件，调用SetEvent方法后，唤醒一个等待的线程后即自动转换为未传信状态。第二种是手动重置事件，调用SetEvent方法后，需要调用ResetEvent方法设置事件为未传信状态。PulseEvent相当于调用SetEvent后立即调用ResetEvent。对于手动重置时间，PulseEvent会唤醒所有等待的线程。而对于自动重置的事件PulseEvent只会唤醒一个等待的线程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
HANDLE
g_taskEvent;
  
unsigned
int
WINAPI ComputationTask(
void
* pvParam)
{
    
WaitForSingleObject(g_taskEvent, INFINITE);
    
for
(
int
i = 0; i < 10; ++i)
    
{
        
cout <<
"comput "
<< i << endl;
    
}
    
return
0;
}
  
int
_tmain(
int
argc, _TCHAR* argv[])
{
    
g_taskEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    
unsigned
int
threadId;
    
HANDLE
thread1 = (
HANDLE
)_beginthreadex(NULL, 0, ComputationTask, NULL, 0, &threadId);
  
    
system
(
"pause"
);
    
SetEvent(g_taskEvent);
    
ResetEvent(g_taskEvent);
  
    
WaitForSingleObject(thread1, INFINITE);
    
system
(
"pause"
);
    
return
0;
}

上面是一个简单的例子，ComputationTask线程等待用户输入后才开始计算任务。

Semaphore

Semaphore维护一个资源计数count和一个最大计数maxCount。

当count大于0时，semaphore处于已传信状态。

当count等于0是，semaphore处于未传信状态。

通过ReleaseSemaphore增加count计数，WaitForSingleObject减少cout计数。count不会小于0，也不能大于maxCount。

例如，可以使用semaphore控制能够同时处理的最大任务线程数。当有超过最大数的更多任务线程开启时只能等待其他任务完成并调用ReleaseSemaphore方法施放资源引用计数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
HANDLE
g_semaphore;
  
unsigned
int
WINAPI RequstProcesor(
void
* pvParam)
{
    
WaitForSingleObject(g_semaphore, INFINITE);
    
cout <<
"Start process request "
<< GetThreadId(GetCurrentThread()) << endl;
    
Sleep(1000);
    
ReleaseSemaphore(g_semaphore, 1, NULL);
    
return
0;
}
  
int
_tmain(
int
argc, _TCHAR* argv[])
{
  
    
g_semaphore = CreateSemaphore(NULL, 2, 2, NULL);
      
    
HANDLE
threads[10];
    
for
(
int
i = 0; i < 10; i++)
    
{
        
threads[i] = (
HANDLE
)_beginthreadex(NULL, 0, RequstProcesor, NULL, 0, NULL);
    
}
  
    
WaitForMultipleObjects(10, threads, TRUE, INFINITE);
    
system
(
"pause"
);
    
return
0;
}

上面的代码，启动了10个线程，但只能有2个现场可以同时执行，更多的线程只能等待。

Mutex

mutex的功能和CriticalSection功能很相似。都是控制一段临界代码的互斥访问。通过WaitForSingleObject等待mutex。ReleaseMutex释放mutex。

mutex维护一个threadId和一个使用计数count。如果CreateMutex的参数bInitialOwner为TRUE，这threadId为调用线程，cout为1。否则都初始为0。

如果threadId为0，mutex没有被任何线程使用，处于已传信状态。如果threadId不为0，mutex处于未传信状态。mutex和其他内核同步对象一个不同的特殊地方在于。即时mutex处于未传信状态。如果调用WaitForSingleObject的线程是mutex的threadId对应的线程，WaitForSingleObject不会阻塞相当于处于已传信状态。下面的例子演示了mutex的使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
HANDLE
g_mutex;
  
void
ProcessA()
{
    
WaitForSingleObject(g_mutex, INFINITE);
    
cout <<
"ProcessA"
<<
" by thread "
<< GetThreadId(GetCurrentThread()) << endl;
    
ReleaseMutex(g_mutex);
}
  
void
ProcessB()
{
    
WaitForSingleObject(g_mutex, INFINITE);
    
ProcessA();
    
cout <<
"ProcessB"
<<
" by thread "
<< GetThreadId(GetCurrentThread()) << endl;
    
ReleaseMutex(g_mutex);
}
  
unsigned
int
WINAPI ThreadFunc(
void
* pvParam)
{
    
ProcessB();
    
return
0;
}
  
int
_tmain(
int
argc, _TCHAR* argv[])
{
    
g_mutex = CreateMutex(NULL, FALSE, NULL);
      
    
HANDLE
threads[10];
    
for
(
int
i = 0; i < 10; i++)
    
{
        
threads[i] = (
HANDLE
)_beginthreadex(NULL, 0, ThreadFunc, NULL, 0, NULL);
    
}
  
    
WaitForMultipleObjects(10, threads, TRUE, INFINITE);
    
system
(
"pause"
);
    
return
0;
}

转载于:https://www.cnblogs.com/lancidie/archive/2012/01/29/2330937.html

你可能感兴趣的文章
Android存储方式之SQLite的使用
查看>>
洛谷P1287 盒子与球 数学
查看>>
Bootstrap vs Foundation如何选择靠谱前端框架
查看>>
与、或、异或、取反、左移和右移
查看>>
vue常用的指令
查看>>
matlab练习程序（随机游走图像）
查看>>
Linux命令行下运行java.class文件
查看>>
input文本框实现宽度自适应代码实例
查看>>
protocol buffers的编码原理
查看>>
行为型设计模式之命令模式(Command)
查看>>
减少死锁的几个常用方法
查看>>
HDFS 核心原理
查看>>
正确配置jstl的maven依赖，jar包冲突的问题终于解决啦
查看>>
利用KMP算法解决串的模式匹配问题（c++) -- 数据结构
查看>>
登录内网账号后，连接不上内网网址
查看>>
安装 MariaDB
查看>>
【deep learning学习笔记】注释yusugomori的DA代码 --- dA.h
查看>>
纯手工打造漂亮的垂直时间轴，使用最简单的HTML+CSS+JQUERY完成100个版本更新记录的华丽转身！...
查看>>
java 为啥变量名前要加个m?
查看>>
探索Android中的Parcel机制（上）
查看>>
喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！-- 愿君每日到此一游！
当前时间: 2025-01-21 12:08:46   当前IP: 3.17.76.178   联系邮箱:javaeecc@qq.com     Copyright © 2020 - 2022 baihongyu.com 京ICP备2021015314号-2
强烈建议你试试无所不能的CHAT-GPT，快点击我
强烈建议你试试无所不能的CHAT-GPT，快点击我