C++博客-Ah.........FreshMeat.-随笔分类-WIN32编程

WIN32多线程五线程同步机制Semaphore

sin — Sun, 14 Mar 2010 17:22:00 GMT

大学操作系统教材里讲的最多的估计就是信号量Semaphore了，具体就不再介绍了，通常用来处理多线程访问多个资源的情况。
实际上，如果创建一个信号量，并且它的最大计数是1，那么它就与Mutex等价。

下面是个生产者-消费者问题的Win32程序，运行时的截图如下:

代码如下:

/* 生产者-消费者问题是一个经典的进程同步问题，该问题最早由Dijkstra提出；很多计算机问题都可以抽象为生产者-消费者问题。
* 有1个生产者生产商品放到环形buffer中供5个消费者消费；生产者每次最多生产5个商品，消费者每次消费1个。
* 要解决这个问题，我们必须确保:(1)并且当缓冲区中没有商品时，消费者不能消费，缓冲区满时，生产者也不能生产商品 (2)不同消费者  * 不能同时消费同一个商品；
*
* 解决(1)我们用一个生产者信号量表示生产者者资源，即空闲buffer数量；用一个消费者信号量表示消费者资源，即非空闲buffer数量。
* 解决(2)我们用一个互斥量Mutex，得到这个Mutex的消费者才能消费。
*/

#include <time.h>
#include <stdlib.h>
#include <Windows.h>

#define ASSERT(a) if (!(a)) \
    exit(EXIT_FAILURE)

#define MAX_PRODUCE_COUNT    5      //生产者每次最多生产数量
#define CONSUMER_COUNT        5     //消费者数量
#define BUFFER_SIZE        20       //缓冲区大小
#define SLEEP_TIME        600
#define WM_FORCE_PAINT        (WM_APP+10)

void    ProduceAndConsume();
void    EndProduceConsume();

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM) ;  //Win32窗口回调函数

DWORD    WINAPI    ProducerThread(LPVOID pVoid);   //生产者线程函数
DWORD    WINAPI    ConsumerThread(LPVOID pVoid);   //消费者线程函数

int        iProducerPointer;         //生产者指针，指向可以放商品的的位置
int        iConsumerPointer;         //消费者指针，指向可以消费商品的位置
HANDLE        hProducerSemaphore;    //生产者信号量，初始有20个资源
HANDLE        hConsumerSemaphore;    //消费者信号量，初始有0个资源
HANDLE        hConsumerMutex;        //生产者Mutex

HANDLE        hProducerThread;                     //生产者线程，不断生产商品
HANDLE        hConsumersThread[CONSUMER_COUNT];    //消费者线程，不断消费商品
HWND        hWnd;

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    PSTR szCmdLine, int iCmdShow)
{
    static TCHAR szAppName[] = TEXT("生长者消费者") ;
    MSG        msg ;
    WNDCLASS    wndclass ;

    wndclass.style        = CS_HREDRAW | CS_VREDRAW ;
    wndclass.lpfnWndProc  = WndProc ;
    wndclass.cbClsExtra   = 0 ;
    wndclass.cbWndExtra   = 0 ;
    wndclass.hInstance    = hInstance ;
    wndclass.hIcon        = LoadIcon (NULL, IDI_APPLICATION) ;
    wndclass.hCursor      = LoadCursor (NULL, IDC_ARROW) ;
    wndclass.hbrBackground= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
    wndclass.lpszMenuName = NULL ;
    wndclass.lpszClassName= szAppName ;

    if (!RegisterClass (&wndclass))
    {
        MessageBox (  NULL, TEXT ("This program requires Windows NT!"),
            szAppName, MB_ICONERROR) ;
        return 0 ;
    }

    hWnd = CreateWindow( szAppName,
        TEXT ("生长者消费者"),
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        NULL,
        NULL,
        hInstance,
        NULL) ;

    ShowWindow (hWnd, iCmdShow) ;
    UpdateWindow (hWnd) ;

    ProduceAndConsume();      //创建生产者消费者线程、信号量、Mutex，并运行

    while (GetMessage (&msg, NULL, 0, 0))
    {
        TranslateMessage (&msg) ;
        DispatchMessage (&msg) ;
    }

    EndProduceConsume();

    return (int)msg.wParam ;
}

LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    int        iTemp;
    int        iXStart,iYStart;
    HDC             hdc ;
    HBRUSH        hBrush;
    PAINTSTRUCT    ps ;
    RECT        rect;
    MSG        msg;

    switch (message)
    {
    case WM_CREATE:
        return 0 ;

    case WM_FORCE_PAINT:
        InvalidateRect(hWnd, NULL, TRUE);
        while (PeekMessage(&msg, hWnd, WM_FORCE_PAINT, WM_FORCE_PAINT, PM_REMOVE))
            ;
        return 0;

    case  WM_PAINT:
        hdc = BeginPaint (hwnd, &ps) ;

        GetClientRect(hWnd,&rect);
        iXStart = (rect.right-rect.left)/2-200;
        iYStart = (rect.bottom-rect.top)/2-10;
        hBrush = SelectObject(hdc, (HBRUSH)GetStockObject(GRAY_BRUSH));
        iTemp = iConsumerPointer;

        while (TRUE)
        {
            Rectangle(hdc, iXStart+iTemp*20, iYStart, iXStart+(iTemp+1)*20, iYStart+20);
            if (++iTemp >= BUFFER_SIZE)
                iTemp = 0;
            if (iTemp == iProducerPointer)
                break;
        }

        SelectObject(hdc, hBrush);

        while (TRUE)
        {
            Rectangle(hdc, iXStart+iTemp*20, iYStart, iXStart+(iTemp+1)*20, iYStart+20);
            if (++iTemp >= BUFFER_SIZE)
                iTemp = 0;
            if (iTemp == iConsumerPointer)
                break;
        }

        EndPaint (hwnd, &ps) ;
        return 0 ;

    case   WM_DESTROY:
        PostQuitMessage (0) ;
        return 0 ;
    }

    return DefWindowProc (hwnd, message, wParam, lParam) ;
}

DWORD WINAPI ProducerThread(LPVOID pVoid)
{
    int        i;
    int        iRandom;

    while (TRUE)
    {
        srand((unsigned)time(NULL));
        iRandom = rand()%MAX_PRODUCE_COUNT;
        if (iRandom == 0)
            iRandom++;

        //生产者申请iRandom个资源
        for (i=0; i<iRandom; i++)
            ASSERT( WAIT_OBJECT_0 == WaitForSingleObject(hProducerSemaphore, INFINITE) );

        //生产者生产iRandom个商品
        iProducerPointer = iProducerPointer+iRandom;
        if (iProducerPointer>=BUFFER_SIZE)
            iProducerPointer = iProducerPointer-BUFFER_SIZE;

        SendMessage(hWnd, WM_FORCE_PAINT, 0, 0);
        Sleep(SLEEP_TIME);

        //生产者生产了iRandom个商品，消费者有更多的商品消费了；所以为消费者释放iRandom个资源
        ASSERT(ReleaseSemaphore(hConsumerSemaphore, (long)iRandom, NULL));
    }

    return 0;
}

DWORD WINAPI ConsumerThread(LPVOID pVoid)
{
    while (TRUE)
    {
        //消费者申请到Semaphore和Mutex后，才能消费
        ASSERT( WAIT_OBJECT_0 == WaitForSingleObject(hConsumerSemaphore, INFINITE) );
        ASSERT( WAIT_OBJECT_0 == WaitForSingleObject(hConsumerMutex, INFINITE) );

        //消费者消费一个商品
        iConsumerPointer++;
        if (iConsumerPointer>=BUFFER_SIZE)
            iConsumerPointer = 0;

        SendMessage(hWnd, WM_FORCE_PAINT, 0, 0);
        Sleep(SLEEP_TIME/2);

        //消费者释放Mutex
        ASSERT(ReleaseMutex(hConsumerMutex));

        //消费者消费了一个商品，buffer中多了一个空闲位置，为生产者释放一个资源
        ASSERT(ReleaseSemaphore(hProducerSemaphore, (long)1, NULL));
    }

    return 0;
}

void ProduceAndConsume()
{
    int        i;
    DWORD    dwThreadID;

    iProducerPointer = 0;
    iConsumerPointer = 0;

    hProducerSemaphore = CreateSemaphore(NULL, BUFFER_SIZE, BUFFER_SIZE, NULL);      //创建生产者信号量，初始有20个资源
    hConsumerSemaphore = CreateSemaphore(NULL, 0, BUFFER_SIZE, NULL);                //创建消费者信号量，初始有0个资源
    hConsumerMutex       = CreateMutex(NULL, FALSE, NULL);                           //创建消费者Mutex

    hProducerThread       = CreateThread(NULL, 0, ProducerThread, NULL, 0, &dwThreadID);
    for (i=0; i<CONSUMER_COUNT; i++)
    {
        hConsumersThread[i] = CreateThread(NULL, 0, ConsumerThread, NULL, 0, &dwThreadID);
    }
}

void EndProduceConsume()
{
    int i;

    ASSERT(CloseHandle(hProducerSemaphore));
    ASSERT(CloseHandle(hConsumerSemaphore));
    ASSERT(CloseHandle(hConsumerMutex));
    ASSERT(CloseHandle(hProducerThread));
    for (i=0; i<CONSUMER_COUNT; i++)
    {
        ASSERT(CloseHandle(hConsumersThread[i]));
    }
}

sin 2010-03-15 01:22 发表评论

WIN32多线程四线程同步机制Mutex

sin — Tue, 23 Feb 2010 09:47:00 GMT

Mutex与CriticalSection相似，都为了处理多个线程对资源的访问。区别是：mutex是内核对象，锁住mutex需要花费更多的时间，mutex可以跨进程存在。没有任何线程拥有mutex，这个mutex处于未激发状态，线程通过调用WaitForXXX来获得此mutex；除非这个线程ReleaseMutex，否则其他线程都不能获得这个mutex的拥有权。
Mutex可以用来解决哲学家就餐问题：让每个哲学家要么获得两根筷子，要么一跟筷子都不获得。哲学家就餐问题中，筷子相当于mutex，每个哲学家要么获得两个mutex，要么一个都不获得。这样就可以防止死锁的发生。

1 /*
2  * MTVERYFY.h   <>作者提供的一个非常好用的宏
3 */
4 #pragma comment( lib, "USER32" )
5
6 #include <crtdbg.h>
7 #define MTASSERT(a) _ASSERTE(a)
8
9
10 #define MTVERIFY(a) if (!(a)) PrintError(#a,__FILE__,__LINE__,GetLastError())
11
12 __inline void PrintError(LPSTR linedesc, LPSTR filename, int lineno, DWORD errnum)
13 {
14     LPSTR lpBuffer;
15     char errbuf[256];
16 #ifdef _WINDOWS
17     char modulename[MAX_PATH];
18 #else // _WINDOWS
19     DWORD numread;
20 #endif // _WINDOWS
21
22     FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER
23         | FORMAT_MESSAGE_FROM_SYSTEM,
24         NULL,
25         errnum,
26         LANG_NEUTRAL,
27         (LPTSTR)&lpBuffer,
28         0,
29         NULL );
30
31     wsprintf(errbuf, "\nThe following call failed at line %d in %s:\n\n"
32         "    %s\n\nReason: %s\n", lineno, filename, linedesc, lpBuffer);
33 #ifndef _WINDOWS
34     WriteFile(GetStdHandle(STD_ERROR_HANDLE), errbuf, strlen(errbuf), &numread, FALSE );
35     Sleep(3000);
36 #else
37     GetModuleFileName(NULL, modulename, MAX_PATH);
38     MessageBox(NULL, errbuf, modulename, MB_ICONWARNING|MB_OK|MB_TASKMODAL|MB_SETFOREGROUND);
39 #endif
40     exit(EXIT_FAILURE);
41 }

1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <Windows.h>
4 #include "MTVERIFY.h"
5
6 #define NUM_PHIL    5
7
8 HANDLE gChopSticks[NUM_PHIL] = {INVALID_HANDLE_VALUE}; //Mutex句柄，用来表示筷子，即哲学家们争取的资源
9 static int flag = 1;
10
11 DWORD WINAPI ThreadFunc(LPVOID); //线程函数，每个线程代表一个哲学家，哲学家们来争夺筷子(即Mutex)资源
12
13 int main()
14 {
15     int i;
16     HANDLE hPhil[NUM_PHIL];
17
18     for (i=0; i<NUM_PHIL; i++)
19     {
20         MTVERIFY( gChopSticks[i] = CreateMutex(NULL, FALSE, NULL) );
21         MTVERIFY( hPhil[i] = CreateThread(NULL, 0, ThreadFunc, (LPVOID)i, 0, NULL) );
22     }
23
24     Sleep(20000); // 主线程睡眠20000ms,这段时间内，所有哲学家想吃饭的时候，争夺筷子资源
25     flag = 0; // 标志置为0，让所有线程都正常退出
26
27     MTVERIFY( WAIT_OBJECT_0 == WaitForMultipleObjects(NUM_PHIL, hPhil, TRUE, INFINITE) );
28     for (i=0; i<NUM_PHIL; i++)
29     {
30         MTVERIFY( CloseHandle(gChopSticks[i]) );
31         MTVERIFY( CloseHandle(hPhil[i]) );
32     }
33
34     system("pause");
35     return 0;
36 }
37
38 DWORD WINAPI ThreadFunc(LPVOID n)
39 {
40     DWORD rc;
41     HANDLE myChopSticks[2];
42     int nIndex = (int)n;
43
44     while ( flag )
45     {
46         myChopSticks[0] = gChopSticks[nIndex%NUM_PHIL];
47         myChopSticks[1] = gChopSticks[(nIndex+1)%NUM_PHIL];
48
49         MTVERIFY( WAIT_OBJECT_0 == WaitForMultipleObjects(2, myChopSticks, TRUE, INFINITE) ); //哲学家等待他身边的两根筷子
50
51         printf("Philosopher # %d is eating\n", nIndex);
52         Sleep(50);
53
54         ReleaseMutex(myChopSticks[0]);
55         ReleaseMutex(myChopSticks[1]);
56     }
57
58     return (DWORD)n;
59 }

sin 2010-02-23 17:47 发表评论

WIN32多线程三线程同步机制Critical Section

sin — Tue, 23 Feb 2010 09:44:00 GMT

就是通常说的"锁"，多线程对同一份资源的同步控制，经常用Critical Section，用来锁住一份资源，以免多个线程"同时"访问一份资源。通过下面
4个函数来使用InitializeCriticalSection EnterCriticalSection LeaveCriticalSection DeleteCriticalSection来使用。

需要注意的地方：不要长时间的锁住一份资源，不要在锁住资源而没有释放的时候调用Sleep WaitXXX。如果进入CriticalSection的那个线程当掉了
，而没有离开CriticalSection，系统没有办法将其清掉，因为它不是内核对象，不归操作系统管理。

另一个注意地方：每次调用EnterCriticalSection，会使该CriticalSection的引用计数加1，一个线程可以多次调用EnterCriticalSection，使计数
减1。调用了多少次EnterCriticalSection，就应该调用多少次LeaveCriticalSection。

下面是个考虑了多线程的链表的例子，但也不是完全多线程安全。

1 #include <Windows.h>
2
3 struct Node
4 {
5     int data;
6     struct Node *next;
7 };
8
9 class List
10 {
11 public:
12     List();
13     ~List();
14
15 public:
16     void    InsertNode(Node *pNode, Node *pNewNode);
17     void    AddHead(Node *pNode);
18     Node   *Next(Node *pNode);
19
20 private:
21     void    Init();
22     void    Destroy();
23
24 private:
25     Node    *m_pHead;
26     CRITICAL_SECTION m_cs;
27 };

1 #include "list.h"
2
3 List::List()
4 {
5     InitializeCriticalSection(&m_cs);
6     Init();
7 }
8
9 List::~List()
10 {
11     Destroy();
12     DeleteCriticalSection(&m_cs);
13 }
14
15 void List::Init()
16 {
17     m_pHead = NULL;
18 }
19
20 void List::Destroy()
21 {
22     Node *pNode;
23     Node *pTemp;
24
25     pNode = m_pHead;
26     while (pNode)
27     {
           pTemp = pNode;
28         pNode = pNode->next;
29         delete pTemp;
30     }
31 }
32
33 void List::InsertNode(Node *pNode, Node *pNewNode)
34 {
35     EnterCriticalSection(&m_cs);
36
37     if (pNode->next)
38     {
39         pNewNode->next = pNode->next;
40         pNode->next = pNewNode;
41     }
42     else
43     {
44         pNode->next = pNewNode;
45     }
46
47     LeaveCriticalSection(&m_cs);
48 }
49
50 void List::AddHead(Node *pNode)
51 {
52     EnterCriticalSection(&m_cs);
53     pNode->next = m_pHead;
54     m_pHead = pNode;
55     LeaveCriticalSection(&m_cs);
56 }
57
58 Node* List::Next(Node *pNode)
59 {
60     Node *pNext;
61
62     EnterCriticalSection(&m_cs);
63     pNext = pNode->next;
64     LeaveCriticalSection(&m_cs);
65
66     return pNext;
67 }

sin 2010-02-23 17:44 发表评论

WIN32多线程二用WaitXXX函数等待线程结束

sin — Mon, 22 Feb 2010 07:45:00 GMT

等待线程结束的更好方法是调用API WaitForSigleObject和WaitForMultipleObjects。前者用于等待一个线程由未激发状态变为激发状态，后者用于等待多个线程中全部或多个中的一个由未激发状态变为激发状态。对线程内核对象而言，如果线程在运行，则是未激发状态；如果线程已经退出，则是激发状态。不同内核对象的激发、未激发状态含义有所不同。

DWORD WINAPI WaitForSingleObject(
__in          HANDLE hHandle,        //等待的内核对象句柄
__in          DWORD dwMilliseconds    //等待的超时时间
);
函数失败，返回WAIT_FAILED；
等待对象变为激发状态，返回WAIT_OBJECT_O；
等待超时，返回WAIT_TIMEOUT；
一个拥有mutex的线程结束前，没有释放掉mutex，则返回WAIT_ABANDONED.

DWORD WINAPI WaitForMultipleObjects(
__in          DWORD nCount,        //等待内核对象个数
__in          const HANDLE* lpHandles,//内核对象数组
__in          BOOL bWaitAll,        //是否等待所有内核对象，还是等待其中一个变为激发状态就返回
__in          DWORD dwMilliseconds    //等待的超时时间
);
函数失败，返回WAIT_FAILED；
等待超时，返回WAIT_TIMEOUT；
bWaitAll为TRUE，所有对象变为激发状态，返回WAIT_OBJECT_O；
bWaitAll为FALSE，返回值减去WAIT_OBJECT_O的值就是变为激发状态内核对象在数组中的索引；
如果内核对象中有mutex，返回值可能在WAIT_ABANDONED到WAIT_ABANDONED+nCount-1。

下面是个<>中用WaitForMultipleObjects实现的简单的线程池的例子，3个线程来完成6个任务。

/*
* MTVERYFY.h
*/
#pragma comment( lib, "USER32" )

#include <crtdbg.h>
#define MTASSERT(a) _ASSERTE(a)

#define MTVERIFY(a) if (!(a)) PrintError(#a,__FILE__,__LINE__,GetLastError())

__inline void PrintError(LPSTR linedesc, LPSTR filename, int lineno, DWORD errnum)
{
    LPSTR lpBuffer;
    char errbuf[256];
#ifdef _WINDOWS
    char modulename[MAX_PATH];
#else // _WINDOWS
    DWORD numread;
#endif // _WINDOWS

    FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER
        | FORMAT_MESSAGE_FROM_SYSTEM,
        NULL,
        errnum,
        LANG_NEUTRAL,
        (LPTSTR)&lpBuffer,
        0,
        NULL );

    wsprintf(errbuf, "\nThe following call failed at line %d in %s:\n\n"
        "    %s\n\nReason: %s\n", lineno, filename, linedesc, lpBuffer);
#ifndef _WINDOWS
    WriteFile(GetStdHandle(STD_ERROR_HANDLE), errbuf, strlen(errbuf), &numread, FALSE );
    Sleep(3000);
#else
    GetModuleFileName(NULL, modulename, MAX_PATH);
    MessageBox(NULL, errbuf, modulename, MB_ICONWARNING|MB_OK|MB_TASKMODAL|MB_SETFOREGROUND);
#endif
    exit(EXIT_FAILURE);
}

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#include "MTVERIFY.h"

#define THREAD_POOL_SIZE  3
#define NUM_TASKS    6

DWORD WINAPI ThreadFunc(LPVOID);

int main()
{
    HANDLE    hThreads[THREAD_POOL_SIZE];
    int        i;
    int        slot = 0;
    DWORD    dwThreadId;
    DWORD    rc;

    for ( i=0; i<NUM_TASKS; i++ )
    {
        if ( i >= THREAD_POOL_SIZE )
        {
            rc = WaitForMultipleObjects(THREAD_POOL_SIZE, hThreads, FALSE, INFINITE);
            slot = rc - WAIT_OBJECT_0;
            MTVERIFY( 0<=slot && slot<THREAD_POOL_SIZE );
            printf("Slot %d terminated.\n",slot);
            MTVERIFY( CloseHandle(hThreads[slot]) );
        }

        MTVERIFY( hThreads[slot++] = CreateThread(NULL, 0, ThreadFunc, (LPVOID)slot, 0, &dwThreadId) );
        printf("Launched thread #%d (slot %d).\n", i, slot);
    }

    rc = WaitForMultipleObjects(THREAD_POOL_SIZE, hThreads, TRUE, INFINITE);
    MTVERIFY( WAIT_OBJECT_0<=rc && rc<WAIT_OBJECT_0+THREAD_POOL_SIZE );

    for ( slot=0; slot<THREAD_POOL_SIZE; slot++ )
    {
        MTVERIFY( CloseHandle(hThreads[slot]) );
    }

    return EXIT_SUCCESS;
}

DWORD WINAPI ThreadFunc(LPVOID n)
{
    srand( GetTickCount() );

    Sleep( (rand()%10)*800+500 );
    printf("Slot %d idle.\n", n);

    return (DWORD)n;
}

sin 2010-02-22 15:45 发表评论

WIN32多线程一用WIN32 API创建和结束线程

sin — Mon, 22 Feb 2010 03:15:00 GMT

Win32中，内核对象属于WINDOWS的，而不属于进程。进程对象、线程对象、文件对象、文件映射对象、事件对象、互斥量对象等都属于内核对象。WIN32中一般通过CreateXXXX来创建内核对象，返回一个内核对象的句柄，进程不能直接操作内核对象，只能通过该句柄来访问内核对象。内核对象有一个使用计数，一个进程的内核对象句柄表中引用了某个内核对象，该内核对象的使用计数就递增1，该进程调用CloseHandle时，引用计数递减，当引用计数为0时，内核对象被销毁，当进程退出时，进程所引用内核对象的引用计数都递减1。

线程也是内核对象，当创建一个线程时，默认引用计数是2。调用CloseHandle时，线程引用计数下降1；当线程结束时，引用计数再下降1。仅仅调用CloseHandle并不能保证线程结束。利用这个特点，我们可以在调用CloseHandle前用GetExitCodeThread获得线程的结束代码，如果线程是STILL_ACTIVE状态，表示线程尚未结束。下面是一个能保证线程正常结束例子:

不过例子中等待线程结束的方法非常笨，用一个for循环不断检测线程状态，如果两个线程都结束了，才跳出循环，更好的方法是WaitForSigleObject，后面介绍。

1 /*
2  * ExitCode.c
3  *
4  * Sample code for "Multithreading Applications in Win32"
5  * This is from Chapter 2, Listing 2-2
6  *
7  * Start two threads and try to exit
8  * when the user presses a key.
9  */
10
11 #define WIN32_LEAN_AND_MEAN
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <windows.h>
15 #include <conio.h>
16
17 DWORD WINAPI ThreadFunc(LPVOID);
18
19 int main()
20 {
21     HANDLE hThrd1;
22     HANDLE hThrd2;
23     DWORD exitCode1 = 0;
24     DWORD exitCode2 = 0;
25     DWORD threadId;
26
27     hThrd1 = CreateThread(NULL,
28         0,
29         ThreadFunc,
30         (LPVOID)1,
31         0,
32         &threadId );
33     if (hThrd1)
34         printf("Thread 1 launched\n");
35
36     hThrd2 = CreateThread(NULL,
37         0,
38         ThreadFunc,
39         (LPVOID)2,
40         0,
41         &threadId );
42     if (hThrd2)
43         printf("Thread 2 launched\n");
44
45
46     // Keep waiting until both calls to
47     // GetExitCodeThread succeed AND
48     // neither of them returns STILL_ACTIVE.
49     // This method is not optimal - we'll
50     // see the correct way in Chapter 3.
51     for (;;)
52     {
53         printf("Press any key to exit..\n");
54         getch();
55
56         GetExitCodeThread(hThrd1, &exitCode1);
57         GetExitCodeThread(hThrd2, &exitCode2);
58         if ( exitCode1 == STILL_ACTIVE )
59             puts("Thread 1 is still running!");
60         if ( exitCode2 == STILL_ACTIVE )
61             puts("Thread 2 is still running!");
62         if ( exitCode1 != STILL_ACTIVE
63             && exitCode2 != STILL_ACTIVE )
64             break;
65     }
66
67     CloseHandle(hThrd1);
68     CloseHandle(hThrd2);
69
70     printf("Thread 1 returned %d\n", exitCode1);
71     printf("Thread 2 returned %d\n", exitCode2);
72
73     return EXIT_SUCCESS;
74 }
75
76
77 /*
78  * Take the startup value, do some simple math on it,
79  * and return the calculated value.
80  */
81 DWORD WINAPI ThreadFunc(LPVOID n)
82 {
83     Sleep((DWORD)n*1000*2);
84     return (DWORD)n * 10;
85 }

线程也可以自己结束掉自己，方法是调用ExitThread。尽量不在主线程中调用ExitTread，这样会强制其他线程终止，进程终止，而其他线程没有机会做清理工作。

sin 2010-02-22 11:15 发表评论

WIN32串口通信类

sin — Sun, 21 Feb 2010 04:53:00 GMT

串口的操作可以有两种操作方式：同步操作方式和重叠操作方式（又称为异步操作方式）。同步操作时，API函数会阻塞直到操作完成以后才能返回（在多线程方式中，虽然不会阻塞主线程，会阻塞串口读写线程）；而重叠操作方式，API函数会立即返回，操作在后台进行，避免线程的阻塞。下面介绍的是同步方式。WIN32串口编程一般分为:打开串口、配置串口、读写串口、关闭串口。

打开串口
WIN32将各种设备、端口都抽象为文件，提供统一的编程接口，打开串口也就是打开文件，通过API CreateFile来完成。
HANDLE WINAPI CreateFile(
__in      LPCTSTR lpFileName,        //文件名，串口通讯中位"COM1" "COM2"等
__in      DWORD dwDesiredAccess,    //访问权限，可以是读、写或读写并行
__in      DWORD dwShareMode,        //共享模式，串口通讯中一般为0
__in      LPSECURITY_ATTRIBUTES lpSecurityAttributes,
                    //安全属性，缺省为NULL
__in      DWORD dwCreationDisposition,//创建标志，对串口操作必须为OPEN_EXISTING
__in      DWORD dwFlagsAndAttributes,    //属性，同步或是异步方式
__in      HANDLE hTemplateFile    //当打开已存在的文件时，忽略此参数
);

配置串口
在打开通讯设备句柄后，常常需要对串口进行一些初始化配置工作。这需要通过一个DCB结构来进行。在查询或配置串口的属性时，都要用DCB结构来作为缓冲区。一般用CreateFile打开串口后，可以调用GetCommState函数来获取串口的初始配置。要修改串口的配置，应该先修改DCB结构，再调用SetCommState函数设置串口。除设置DCB外，还要设置串口缓冲区大小，通过API SetupComm完成；设置超时时间，通过SetCommTimeouts完成；开始读写串口前，还要通过API PurgeComm来清空缓冲区。这几个API详细信息可查看MSDN,不同情况设置参数可能不一样。

涉及的结构体有DCB 和 COMMTIMEOUTS,详细说明可查看MSDN。

typedef struct _DCB{    //仅列出几个常用的配置项:
   ………
   DWORD BaudRate;     //波特率
   DWORD fParity;      //指定是否允许奇偶校验。若此成员为1，允许奇偶校验检查
   BYTE ByteSize;      //通信字节位数，4—8
   BYTE Parity;        //指定奇偶校验方法。此成员可以有下列值：
                       //EVENPARITY 偶校验     NOPARITY 无校验
                       //MARKPARITY 标记校验   ODDPARITY 奇校验
   BYTE StopBits;      //指定停止位的位数。此成员可以有下列值：
                       //ONESTOPBIT   1位停止位
                       //TWOSTOPBITS 2位停止
                       //ONE5STOPBITS 1.5位停止位
   ………
} DCB;

typedef struct _COMMTIMEOUTS {
    DWORD ReadIntervalTimeout;           //读间隔超时
    DWORD ReadTotalTimeoutMultiplier;    //读时间系数
    DWORD ReadTotalTimeoutConstant;      //读时间常量
    DWORD WriteTotalTimeoutMultiplier; //写时间系数
    DWORD WriteTotalTimeoutConstant;     //写时间常量
} COMMTIMEOUTS,*LPCOMMTIMEOUTS;

读写串口
跟读写普通文件一样，通过ReadFile 和 WriteFile来完成。如果有多个线程访问串口的话，要做好不同线程的同步，简单的方法可通过WIN32的关键代码段来同步,避免多个线程同时访问串口。

关闭串口
利用API CloseHandle关闭即可。

上面只是简单介绍了WIN32串口编程，更多具体的信息如DCB的设置、串口超时设置、缓冲区大小设置，可能需要在具体调试中根据情况来设置。特别重要的一点是多线程的同步问题，特别在串口数据传输速度很快的时候，需要仔细设计。

1 class CCommPort
2 {
3 public:
4     CCommPort();
5     virtual ~CCommPort();
6
7     BOOL Open( LPCTSTR szPort, int nBaud, int nDataBit, int nStopBit, int nParity );
8     BOOL Close();
9
10     BOOL Write( LPVOID pBuf, int nSize, DWORD& dwWritten );
11     BOOL Read( LPVOID pBuf, int nSize, DWORD& dwReaded );
12     void Clear();
13
14     BOOL IsOpen();
15
16 private:
17     HANDLE         m_handle;
18     CRITICAL_SECTION m_cs;
19 };

sin 2010-02-21 12:53 发表评论

C++博客-Ah.........FreshMeat.-随笔分类-WIN32编程

WIN32多线程五 线程同步机制Semaphore

WIN32多线程四 线程同步机制Mutex

WIN32多线程三 线程同步机制Critical Section