使用线程——创建线程

CreateThread函数创建一个进程的新的线程。创建线程必须指定新线程要执行的代码的起始地址。通常，起始地址是程序代码中定义的函数的名称（有关更多信息，请参阅ThreadProc）。此函数采用单个参数并返回DWORD值。一个进程可以让多个线程同时执行相同的功能。

以下是演示如何创建执行本地定义函数的新线程的简单示例MyThreadFunction。

调用线程使用WaitForMultipleObjects函数持久化，直到所有工作线程终止。调用线程在等待时阻塞; 为了继续处理，调用线程将使用WaitForSingleObject并等待每个工作线程发信号通知其等待对象。请注意，如果要在终止之前关闭工作线程的句柄，则不会终止工作线程。但是，句柄将不可用于后续函数调用。

#include <windows.h>
#include <tchar.h>
#include <strsafe.h>

#define MAX_THREADS 3
#define BUF_SIZE 255

DWORD WINAPI MyThreadFunction( LPVOID lpParam );
void ErrorHandler(LPTSTR lpszFunction);

// Sample custom data structure for threads to use.
// This is passed by void pointer so it can be any data type
// that can be passed using a single void pointer (LPVOID).
typedef struct MyData {
    int val1;
    int val2;
} MYDATA, *PMYDATA;


int _tmain()
{
    PMYDATA pDataArray[MAX_THREADS];
    DWORD   dwThreadIdArray[MAX_THREADS];
    HANDLE  hThreadArray[MAX_THREADS]; 

    // Create MAX_THREADS worker threads.

    for( int i=0; i<MAX_THREADS; i++ )
    {
        // Allocate memory for thread data.

        pDataArray[i] = (PMYDATA) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                sizeof(MYDATA));

        if( pDataArray[i] == NULL )
        {
           // If the array allocation fails, the system is out of memory
           // so there is no point in trying to print an error message.
           // Just terminate execution.
            ExitProcess(2);
        }

        // Generate unique data for each thread to work with.

        pDataArray[i]->val1 = i;
        pDataArray[i]->val2 = i+100;

        // Create the thread to begin execution on its own.

        hThreadArray[i] = CreateThread( 
            NULL,                   // default security attributes
            0,                      // use default stack size  
            MyThreadFunction,       // thread function name
            pDataArray[i],          // argument to thread function 
            0,                      // use default creation flags 
            &dwThreadIdArray[i]);   // returns the thread identifier 


        // Check the return value for success.
        // If CreateThread fails, terminate execution. 
        // This will automatically clean up threads and memory. 

        if (hThreadArray[i] == NULL) 
        {
           ErrorHandler(TEXT("CreateThread"));
           ExitProcess(3);
        }
    } // End of main thread creation loop.

    // Wait until all threads have terminated.

    WaitForMultipleObjects(MAX_THREADS, hThreadArray, TRUE, INFINITE);

    // Close all thread handles and free memory allocations.

    for(int i=0; i<MAX_THREADS; i++)
    {
        CloseHandle(hThreadArray[i]);
        if(pDataArray[i] != NULL)
        {
            HeapFree(GetProcessHeap(), 0, pDataArray[i]);
            pDataArray[i] = NULL;    // Ensure address is not reused.
        }
    }

    return 0;
}


DWORD WINAPI MyThreadFunction( LPVOID lpParam ) 
{ 
    HANDLE hStdout;
    PMYDATA pDataArray;

    TCHAR msgBuf[BUF_SIZE];
    size_t cchStringSize;
    DWORD dwChars;

    // Make sure there is a console to receive output results. 

    hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
    if( hStdout == INVALID_HANDLE_VALUE )
        return 1;

    // Cast the parameter to the correct data type.
    // The pointer is known to be valid because 
    // it was checked for NULL before the thread was created.

    pDataArray = (PMYDATA)lpParam;

    // Print the parameter values using thread-safe functions.

    StringCchPrintf(msgBuf, BUF_SIZE, TEXT("Parameters = %d, %d\n"), 
        pDataArray->val1, pDataArray->val2); 
    StringCchLength(msgBuf, BUF_SIZE, &cchStringSize);
    WriteConsole(hStdout, msgBuf, (DWORD)cchStringSize, &dwChars, NULL);

    return 0; 
} 



void ErrorHandler(LPTSTR lpszFunction) 
{ 
    // Retrieve the system error message for the last-error code.

    LPVOID lpMsgBuf;
    LPVOID lpDisplayBuf;
    DWORD dw = GetLastError(); 

    FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
        FORMAT_MESSAGE_FROM_SYSTEM |
        FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL,
        dw,
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
        (LPTSTR) &lpMsgBuf,
        0, NULL );

    // Display the error message.

    lpDisplayBuf = (LPVOID)LocalAlloc(LMEM_ZEROINIT, 
        (lstrlen((LPCTSTR) lpMsgBuf) + lstrlen((LPCTSTR) lpszFunction) + 40) * sizeof(TCHAR)); 
    StringCchPrintf((LPTSTR)lpDisplayBuf, 
        LocalSize(lpDisplayBuf) / sizeof(TCHAR),
        TEXT("%s failed with error %d: %s"), 
        lpszFunction, dw, lpMsgBuf); 
    MessageBox(NULL, (LPCTSTR) lpDisplayBuf, TEXT("Error"), MB_OK); 

    // Free error-handling buffer allocations.

    LocalFree(lpMsgBuf);
    LocalFree(lpDisplayBuf);
}

该MyThreadFunction函数避免使用C运行时库（CRT），因为它的许多函数都不是线程安全的，特别是如果您不使用多线程CRT。如果要在ThreadProc函数中使用CRT ，请改用_beginthreadex函数。

如果创建线程在新线程之前退出，则传递局部变量的地址是有风险的，因为指针变为无效。相反，要么将指针传递给动态分配的内存，要么让创建线程等待新线程终止。数据也可以使用全局变量从创建线程传递到新线程。对于全局变量，通常需要通过多个线程同步访问。有关同步的详细信息，请参阅同步多个线程的执行。

创建线程可以使用CreateThread的参数来指定以下内容：

新线程句柄的安全属性。这些安全属性包括一个继承标志，用于确定子进程是否可以继承句柄。安全性属性还包括安全描述符，系统使用该描述符在授予访问权限之前对线程句柄的所有后续使用执行访问检查。
新线程的初始堆栈大小。线程的堆栈自动分配在进程的内存空间中; 系统根据需要增加堆栈，并在线程终止时释放它。有关更多信息，请参阅线程堆栈大小。
一个创建标志，使您可以创建处于挂起状态的线程。挂起时，线程不会运行，直到调用ResumeThread函数。
您还可以通过调用CreateRemoteThread函数来创建线程。调试器进程使用此函数来创建在正在调试的进程的地址空间中运行的线程。

相关话题

终止线程