和线程有关的函数结构

HANDLE WINAPI 
CreateThread(
    __in_opt  LPSECURITY_ATTRIBUTES lpThreadAttributes,
    __in      SIZE_T dwStackSize,
    __in      LPTHREAD_START_ROUTINE lpStartAddress,
    __in_opt  LPVOID lpParameter,
    __in      DWORD dwCreationFlags,
    __out_opt LPDWORD lpThreadId
    );      创建线程

第一个参数是指向SECURITY_ATTRIBUTES型态的结构的指针。在Windows 98中忽略该参数。在Windows NT中，它被设为NULL。

第二个参数是用于新线程的初始堆栈大小，默认值为0。在任何情况下，Windows根据需要动态延长堆栈的大小。

第三个参数是指向线程函数的指标。函数名称没有限制，但是必须以下列形式声明：

DWORD WINAPI ThreadProc (PVOID pParam) ;
第四个参数为传递给ThreadProc的参数。这样主线程和从属线程就可以共享数据。
第五个参数通常为0，但当建立的线程不马上执行时为旗标Create_SUSPENDED。线程将暂停直到呼叫ResumeThread来恢复线程的执行为止。

第六个参数是一个指标，指向接受执行绪ID值的变量。

DWORD WNDAPI ThreadFunc( LPVOID lParam ); 线程函数

 

BOOL WINAPI CloseHandle( __in HANDLE hObject ); 关闭内核引用对象

BOOL WINAPI GetExitCodeThread(__in  HANDLE hThread,__out LPDWORD lpExitCode); 获取线程返回值 线程没结束返回 STILE_ACTIVE

 

VOID ExitThread( DWORD dwExitCode ); 退出线程

 

BOOL WINAPI TerminateThread( __in HANDLE hThread, __in DWORD dwExitCode  ); 终止线程

 

DWORD WINAPI SuspendThread(  __in HANDLE hThread   ); 挂起线程
    

DWORD WINAPI ResumeThread( __in HANDLE hThread ); 开启线程

DWORD WINAPI WaitForSingleObject( __in HANDLE hHandle,  __in DWORD dwMilliseconds  );

返回值：   
      WAIT_ABANDONED:   指定对象是互斥对象，在线程被终止前，线程没有释放互斥对象。互斥对象的所属关系被授予调用线程，并且该互斥对象被置为非信号态。   
      WAIT_OBJECT_0:     指定对象的状态被置为信号状态。   
      WAIT_TIMEOUT:       超时，并且对象的状态为非信号态。   
      WAIT_FAILED:          调用失败。

 

DWORD WINAPI
WaitForMultipleObjects(
    __in DWORD nCount,
    __in_ecount(nCount) CONST HANDLE *lpHandles,
    __in BOOL bWaitAll,
    __in DWORD dwMilliseconds
    );

DWORD WINAPI
MsgWaitForMultipleObjects(
    __in DWORD nCount,
    __in_ecount_opt(nCount) CONST HANDLE *pHandles,
    __in BOOL fWaitAll,
    __in DWORD dwMilliseconds,
    __in DWORD dwWakeMask);

临界区

VOID WINAPI InitializeCriticalSection(__out LPCRITICAL_SECTION lpCriticalSection  );

 

VOID WINAPI EnterCriticalSection( __inout LPCRITICAL_SECTION lpCriticalSection );

VOID WINAPI LeaveCriticalSection( __inout LPCRITICAL_SECTION lpCriticalSection   );

VOID WINAPI DeleteCriticalSection( __inout LPCRITICAL_SECTION lpCriticalSection  );

互斥体

HANDLE WINAPI
CreateMutex(
    __in_opt LPSECURITY_ATTRIBUTES lpMutexAttributes, 安全属性
    __in     BOOL bInitialOwner,    如果想让创建该互斥体的线程拥有该互斥体 就为TRUE 相当于调用了
    __in_opt LPCWSTR lpName   互斥体的名字                                                    WaitForSingleObject
    );

BOOL WINAPI ReleaseMutex(__in HANDLE hMutex  ); 释放互斥体

 

信号量

当信号值为0时 waitf就回等待，当信号值为2时表示还可以调用两次waitf，和互斥体不一样的地方就是他有信号可以调用waitf不等待 ， 而互斥体有信号调用waitf回等待

 HANDLE WINAPI
CreateSemaphoreW(
    __in_opt LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, 安全属性
    __in     LONG lInitialCount,        信号的初始值 大于等于0   小于等于lMaximumCount
    __in     LONG lMaximumCount,  使用此信号的最多线程数
    __in_opt LPCWSTR lpName      信号 名称
    );

BOOL WINAPI
ReleaseSemaphore(
    __in      HANDLE hSemaphore,  信号对象
    __in      LONG lReleaseCount,   释放信号时在原来的信号值上加上这个数（不能为0） 总和不能超过lMaximumCount  否则调用不成功
    __out_opt LPLONG lpPreviousCount 表示在释放之前的信号值                                    

      );
   

 事件 激发状态调用waitf不用等待

HANDLEWINAPI
CreateEventW(
    __in_opt LPSECURITY_ATTRIBUTES lpEventAttributes,
    __in     BOOL bManualReset,  为 TRUE 表示不能自动置为非激发 调用waitf后不能自己变成非激发状态
    __in     BOOL bInitialState,   为 TRUE 表示处于激发状态
    __in_opt LPCWSTR lpName  事件名称
    );

BOOL WINAPI SetEvent( __in HANDLE hEvent    );  将事件变为激发状态

BOOL WINAPI ResetEvent(  __in HANDLE hEvent ); 将事件变为非激发状态

BOOL WINAPI PulseEvent( __in HANDLE hEvent ); 如果事件为手动事件，调用此函数， 会是所有的等待中的线程激活，然后将hEvent变为非激发状态， 如果事件为自动事件，调用此函数，会是一个等待中的线程激活，然后将hEvent变为非激发状态

互锁

帮助理解线程的例子
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>


//函数声明
DWORD ThreadProc (LPVOID lpdwThreadParam);


//Global variable Shared by all threads
int nGlobalCount = 0;










//Main function which starts out each thread
int __cdecl main( int argc, char **argv)
{ 
int i, nThreads = 5;
DWORD dwThreadId;
//Determine the number of threads to start
if (argc > 1) {//基本没什么用
printf("argc > 1");
nThreads = atoi( argv[1]);
}


//Set the global count to number of threads
nGlobalCount = nThreads;
//Start the threads
for (i=1; i<= nThreads; i++) {
//printf("i - %d\n",i);
if (CreateThread(NULL, //Choose default security//设置线程安全级别
0, //Default stack size//设置堆栈大小
(LPTHREAD_START_ROUTINE)&ThreadProc,//Routine to execute，指定的新线程的地址
(LPVOID) &i, //Thread parameter,传递线程参数
0, //Immediately run the thread立即执行该线程
&dwThreadId //Thread Id
) == NULL)
{
printf("Error Creating Thread#: %d\n",i);
return(1);
}
else
{
printf("Global Thread Count: %d %d %d\n", nGlobalCount, nThreads, i);
Sleep(1000);
}
}
return 0;
}


//Thread Routine
DWORD ThreadProc (LPVOID lpdwThreadParam ) //LPVOID是一个没有类型的指针，也就是说你可以将任意类型的指针赋值给LPVOID类型的变量（一般作为参数传递），然后在使用的时候再转换回来。
{
//Print Thread Number
printf ("Thread #: %d\n", *((int*)lpdwThreadParam));
//Reduce the count
nGlobalCount--;
//ENd of thread
return 0;
}