windows平台的多线程同步互斥:从内核源码分析----小话多线程(3)
日期：2012-8-16 13:05:34
环境：[win7 32位操作系统 Intel i3 支持64位指令 VS2010; wrk-v1.2 ; Source Insight]
转载请注明出处
Q1： 举个windows平台简单的线程例子吧。
A： 如下，保存为thread_test.c：
#include <windows.h>
#include <stdio.h>
#define PRINT_U(ulongValue) printf(#ulongValue" is %lu\n", ((unsigned long)ulongValue));
int main()
{
HANDLE thread = GetCurrentThread();
HANDLE process = GetCurrentProcess();
PRINT_U(GetThreadId(thread))
PRINT_U(GetProcessId(process))
getchar();
return 0;
} 编译成thread_test.exe, 运行：
可以看到，获得了此线程的ID和所属进程的ID; 我们同时可以从任务管理器中查看：
这里也可以看到，PID确实是输出的那样，线程数为1，这表明只有一个主线程。如果希望查看更多的信息，可以使用微软提供的procexp.exe(sysinternals提供)查看：
可以看到上面thread_text.exe进程所属的位置。双击进入：
这里可以看到，此线程的ID，确实是上面输出的7416; 同时也可以看到，此线程是从_mainCRTStartup运行的。点击stack按钮查看具体堆栈信息：
上面的图示具体描述了此线程运行的堆栈信息，同时也可以看到线程运行在不同模块的位置(注意: ntkr128g.exe是本机因为要识别4G内存新安装的内核，正常情况下是ntoskrnl.exe或者ntkrnlpa.exe. ). 这里也可以看到线程运行于内核状态调用的关系。
Q2： CreateThread和_beginthread到底有什么区别？为什么人们老说使用CreateThread可能导致内存泄露？
A： 从目的的角度来说，它们都是为了创建一个线程；但是具体到细节，它们又有不同：前者是系统API，这意味着它没有和通常程序会使用的C库等库绑定，后者是微软提供的c运行时函数。所以，_beginthread可能会做一些维持c库正常运行的事情，而CreateThread函数就很单纯。查看它们的源代码会很容易找到它们的区别，这里就不贴代码了。
如果已经知道它们所属的层次不同，就很容易理解为什么CreateThread创建线程可能会导致内存泄露了。
不过在win7或者2003 server等平台上，即使使用CreateThread创建子线程, 子线程中调用c库函数strtok, 依然不会发生泄露，原因在于线程退出释放Fiber Local Storage从而正确地释放了线程局部存储的数据。
如下代码：
#include <windows.h>
#include <stdio.h>
#include <process.h>
#define PRINT_U(ulongValue) printf(#ulongValue" is %lu\n", ((unsigned long)ulongValue));
DWORD thread_func(LPVOID *arg)
{
char str[] = "111,222,333";
char *p;
printf("thread_func begins...\n");
// print all tokens seperated by ','
p = strtok(str, ",");
while(p)
{
printf("token:%s \n", p);
p = strtok(NULL, ",");
}
printf("thread_func ends...\n");
return 0;
}
int main()
{
HANDLE thread;
thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)thread_func, NULL, 0, NULL);
if(!thread)
{
perror("CreateThread error");
return -1;
}
WaitForSingleObject(thread, INFINITE); // wait for son thread to exit
CloseHandle(thread);
printf("main thread will end...\n");
return 0;
}
在tidtable.c文件中的_freefls函数开始加断点，调试运行：
可以看到，子线程退出线程过程中执行了_freefls函数，它的内部将释放TLS结构ptd.
当然，依然要注意：此程序链接C库的方式是静态链接，即采用/MT或者/MTd方式，而不是采用动态链接DLL的方式/MD或者/MDd的方式。因为采用动态链接C库的方式DLL初始化和退出时会自动释放TLS数据，而无法验证ExitThread是否释放TLS.
另外，正如上面之前提到的，我在win7以及windows server 2003的虚拟机上面运行程序，都符合上面的分析，即CreateThread创建线程后线程内部调用使用TLS结构的函数，比如strtok后，并不会造成内存泄露；但是，我在XP上运行此程序，就发现了内存泄露。具体就不贴图了，大家可以自行测试(最好使用while循环不断创建线程这样很明显观察到内存泄露的过程，在win7或者windows server 2003上，内存会上下浮动，但是随着线程结束释放了对应的结构，进程占用的内存始终保持在一个小波动的范围，而在xp上明显能看到内存使用迅速增加)。
不过不管一个进程泄露了多少内存，最终进程结束的时候都会释放这些内存，所以当结束后，这些内存被回收了，不用害怕你的机器运行了几次内存没了。
另外，我查了一下ntdll.dll模块中_RtlProcessFlsData函数的出处，发现它是从vista系统开始引入的，所以我猜测vista系统和上面的win7, server 2003运行情况类似，这个没有测试，如果谁正好有这个系统或虚拟机，方便测试，可以帮忙测试一下。
Q3： CreateEvent创建的事件对象和CreateMutex创建的互斥体到底有什么区别？
A： 其实event直观的感觉更倾向于同步，而mutex更倾向于互斥；但是，同步互斥本来就不是矛盾体，同步有时就意味着互斥，互斥也就意味着需要同步，很多时候它们是结合在一起使用的。对于mutex不再举例，下面对于event举个例子，保存为test_event.c：
#include <windows.h>
#include <stdio.h>
#include <process.h>
#include <tchar.h>
#define PRINT_U(ulongValue) printf(#ulongValue" is %lu\n", ((unsigned long)ulongValue));
HANDLE waitDataEvent;
HANDLE waitThreadEndEvent;
static int data = 0;
DWORD thread_func(LPVOID *arg)
{
printf("thread_func begins...\n");
WaitForSingleObject(waitDataEvent, INFINITE); // wait for the dataEvent's be signaled
Sleep(1000);
printf("son thread update:main thread has set data:%d...\n", data);
printf("thread_func ends...\n");
SetEvent(waitThreadEndEvent); // tell main thread that it will exit
return 0;
}
int main()
{
HANDLE thread;
thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)thread_func, NULL, 0, NULL);
if(!thread)
{
perror("CreateThread error");
return -1;
}
waitDataEvent = CreateEvent(NULL, TRUE, FALSE, _T("dataEvent")); // init to FALSE
if(!waitDataEvent)
{
perror("CreateEvent waitDataEvent error");
CloseHandle(thread);
return -1;
}
waitThreadEndEvent = CreateEvent(NULL, TRUE, FALSE, _T("threadEvent")); // init to FALSE
if(!waitThreadEndEvent)
{
perror("CreateEvent waitThreadEndEvent error");
CloseHandle(thread);
CloseHandle(waitDataEvent);
return -1;
}
Sleep(2000);
// set data and let son thread go on...
data = 1;
SetEvent(waitDataEvent);
// wait the son thread end
WaitForSingleObject(waitThreadEndEvent, INFINITE);
Sleep(1000);
CloseHandle(thread);
CloseHandle(waitDataEvent);
CloseHandle(waitThreadEndEvent);
printf("main thread will end...\n");
return 0;
}
上面可以清晰地看到，子线程首先等待主线程修改data的数值，然后输出它，之后准备结束，通知主线程它将要结束；
主线程修改data后发送data修改的事件，然后就等待子线程发送结束事件，然后结束。
这样的话，主线程和子线程可以按照预定的步骤执行，而不会出现执行顺序出错的问题，运行结果：
Q4： 形如上面的例子CreateEvent创建的event在内核中到底是什么？
A： 为了更清楚地弄清楚它到底是什么，我们先查看内核源代码(wrkv1.2, nt内核源代码，windows xp, windows server 2003内核源代码)。
NTSTATUS
NtCreateEvent (
__out PHANDLE EventHandle,
__in ACCESS_MASK DesiredAccess,
__in_opt POBJECT_ATTRIBUTES ObjectAttributes,
__in EVENT_TYPE EventType,
__in BOOLEAN InitialState
)
首先我们看到上面的声明是CreateEvent的内核实现函数声明。具体实现如下：
NTSTATUS
NtCreateEvent (
__out PHANDLE EventHandle,
__in ACCESS_MASK DesiredAccess,
__in_opt POBJECT_ATTRIBUTES ObjectAttributes,
__in EVENT_TYPE EventType,
__in BOOLEAN InitialState
)
/*++
Routine Description:
This function creates an event object, sets it initial state to the
specified value, and opens a handle to the object with the specified
desired access.
Arguments:
EventHandle - Supplies a pointer to a variable that will receive the
event object handle.
DesiredAccess - Supplies the desired types of access for the event object.
ObjectAttributes - Supplies a pointer to an object attributes structure.
EventType - Supplies the type of the event (autoclearing or notification).
InitialState - Supplies the initial state of the event object.
Return Value:
NTSTATUS.
--*/
{
PVOID Event;
HANDLE Handle;
KPROCESSOR_MODE PreviousMode;
NTSTATUS Status;
//
// Get previous processor mode and probe output handle address if
// necessary.
//
PreviousMode = KeGetPreviousMode();
if (PreviousMode != KernelMode) {
try {
ProbeForWriteHandle(EventHandle);
} except(EXCEPTION_EXECUTE_HANDLER) {
return GetExceptionCode();
}
}
//
// Check argument validity.
//
if ((EventType != NotificationEvent) && (EventType != SynchronizationEvent)) {
return STATUS_INVALID_PARAMETER;
}
//
// Allocate event object.
//
Status = ObCreateObject(PreviousMode,
ExEventObjectType,
ObjectAttributes,
PreviousMode,
NULL,
sizeof(KEVENT),
0,
0,
&Event);
//
// If the event object was successfully allocated, then initialize the
// event object and attempt to insert the event object in the current
// process' handle table.
//
if (NT_SUCCESS(Status)) {
KeInitializeEvent((PKEVENT)Event, EventType, InitialState);
Status = ObInsertObject(Event,
NULL,
DesiredAccess,
0,
NULL,
&Handle);
//
// If the event object was successfully inserted in the current
// process' handle table, then attempt to write the event object
// handle value. If the write attempt fails, then do not report
// an error. When the caller attempts to access the handle value,
// an access violation will occur.
//
if (NT_SUCCESS(Status)) {
if (PreviousMode != KernelMode) {
try {
*EventHandle = Handle;
} except(EXCEPTION_EXECUTE_HANDLER) {
NOTHING;
}
} else {
*EventHandle = Handle;
}
}
}
//
// Return service status.
//
return Status;
}
我们能够发现，它主要调用了3个函数：ObCreateObject, KeInitializeEvent和ObInsertObject.
第一个主要是创建一个对象，第二个为内核初始化event对象，第三个是将此对象插入进程句柄表中。
对于KeInitializeEvent函数的实现，如下：
VOID
KeInitializeEvent (
__out PRKEVENT Event,
__in EVENT_TYPE Type,
__in BOOLEAN State
)
/*++
Routine Description:
This function initializes a kernel event object. The initial signal
state of the object is set to the specified value.
Arguments:
Event - Supplies a pointer to a dispatcher object of type event.
Type - Supplies the type of event; NotificationEvent or
SynchronizationEvent.
State - Supplies the initial signal state of the event object.
Return Value:
None.
--*/
{
//
// Initialize standard dispatcher object header, set initial signal
// state of event object, and set the type of event object.
//
Event->Header.Type = (UCHAR)Type;
Event->Header.Size = sizeof(KEVENT) / sizeof(LONG);
Event->Header.SignalState = State;
InitializeListHead(&Event->Header.WaitListHead);
return;
}
对于event结构：
typedef struct _KEVENT {
DISPATCHER_HEADER Header;
} KEVENT, *PKEVENT, *PRKEVENT;
typedef struct _DISPATCHER_HEADER {
union {
struct {
UCHAR Type; // obj type
union {
UCHAR Absolute;
UCHAR NpxIrql;
};
union {
UCHAR Size; // obj size，unit as sizeof(DWORD)
UCHAR Hand;
};
union {
UCHAR Inserted;
BOOLEAN DebugActive;
};
};
volatile LONG Lock;
};
LONG SignalState;
LIST_ENTRY WaitListHead; // the objs that wait for this obj
} DISPATCHER_HEADER;
从上面，我们可以看出，对于event,内核其实保存了一个数据对象，并记录了它的基本状态和等待列表。
可是内核调度线程是如何决定哪个线程该挂起，哪个可以就绪或者运行，保证线程同步互斥的正确的呢？
正如下面NtSetEvent代码内部做的那样，它内部会调用KiWaitTestSynchronizationObject函数：
FORCEINLINE
VOID
KiWaitTestSynchronizationObject (
IN PVOID Object,
IN KPRIORITY Increment
)
/*++
Routine Description:
This function tests if a wait can be satisfied when a synchronization
dispatcher object attains a state of signaled. Synchronization objects
include synchronization events and synchronization timers.
Arguments:
Object - Supplies a pointer to an event object.
Increment - Supplies the priority increment.
Return Value:
None.
--*/
{
PKEVENT Event = Object;
PLIST_ENTRY ListHead;
PRKTHREAD Thread;
PRKWAIT_BLOCK WaitBlock;
PLIST_ENTRY WaitEntry;
//
// As long as the signal state of the specified event is signaled and
// there are waiters in the event wait list, then try to satisfy a wait.
//
ListHead = &Event->Header.WaitListHead;
ASSERT(IsListEmpty(&Event->Header.WaitListHead) == FALSE);
WaitEntry = ListHead->Flink;
do {
//
// Get the address of the wait block and the thread doing the wait.
//
WaitBlock = CONTAINING_RECORD(WaitEntry, KWAIT_BLOCK, WaitListEntry);
Thread = WaitBlock->Thread;
//
// If the wait type is wait any, then satisfy the wait, unwait the
// thread with the wait key status, and exit loop. Otherwise, unwait
// the thread with a kernel APC status and continue the loop.
//
if (WaitBlock->WaitType == WaitAny) {
Event->Header.SignalState = 0;
KiUnwaitThread(Thread, (NTSTATUS)WaitBlock->WaitKey, Increment);
break;
}
KiUnwaitThread(Thread, STATUS_KERNEL_APC, Increment);
WaitEntry = ListHead->Flink;
} while (WaitEntry != ListHead);
return;
}它将对此event的等待线程列表挨个发送激活信号, 当然最后线程会不会可以继续执行那依赖于它们具体设置的状态。它内部的核心代码为KiUnwaitThread函数：
VOID
FASTCALL
KiUnwaitThread (
IN PRKTHREAD Thread,
IN LONG_PTR WaitStatus,
IN KPRIORITY Increment
)
/*++
Routine Description:
This function unwaits a thread, sets the thread's wait completion status,
calculates the thread's new priority, and either readies the thread for
execution or adds the thread to a list of threads to be readied later.
Arguments:
Thread - Supplies a pointer to a dispatcher object of type thread.
WaitStatus - Supplies the wait completion status.
Increment - Supplies the priority increment that is to be applied to
the thread's priority.
Return Value:
None.
--*/
{
//
// Unlink thread from the appropriate wait queues and set the wait
// completion status.
//
KiUnlinkThread(Thread, WaitStatus);
//
// Set unwait priority adjustment parameters.
//
ASSERT(Increment >= 0);
Thread->AdjustIncrement = (SCHAR)Increment;
Thread->AdjustReason = (UCHAR)AdjustUnwait;
//
// Ready the thread for execution.
//
KiReadyThread(Thread);
return;
}
我想我不用解释KiReadyThread的意义了。当然，对于其它同步互斥对象，比如mutex， 实现互斥的过程也是类似的，这里不一一列举了。
Q5： windows上可以使用pthread函数库吗？
A： 微软官方貌似没有发布pthread库，但是有开源代码，详情请进：http://sources.redhat.com/pthreads-win32/
作者：陈曦
日期：2012-8-16 13:05:34
环境：[win7 32位操作系统 Intel i3 支持64位指令 VS2010; wrk-v1.2 ; Source Insight]
转载请注明出处