Multithreading programming under Win32 API

      Win32 API yes Windows The interface between the operating system kernel and the application , It wraps the functions provided by the kernel , The application program obtains the corresponding system functions by calling related functions . To provide multithreading functionality to applications ,Win32 API The function set provides some function sets that deal with multithreaded programs . Direct use Win32 API Programming has many advantages : be based on Win32 The application execution code is small , High operational efficiency , But it requires programmers to write more code , And you need to manage all the resources provided by the system to the program . use Win32 API Writing programs directly requires programmers to Windows Have a certain understanding of the system kernel , It will take programmers a lot of time to manage system resources , Therefore, the working efficiency of programmers is reduced .

1. use Win32 Function to create and terminate threads

        Win32 The function library provides functions for multithreading operation , Including creating threads 、 Thread termination 、 Establish mutually exclusive zones, etc . The function to create a new thread in the main thread or other active threads of the application is as follows ：

HANDLE CreateThread(
      lpThreadAttributes: Pointer;                    { Security Settings }
      dwStackSize: DWORD;                              { Stack size }
      lpStartAddress: TFNThreadStartRoutine; { Entry function }
      lpParameter: Pointer;                                { Function parameter }
      dwCreationFlags: DWORD;                       { Startup options }
      var lpThreadId: DWORD                         { Output thread ID }
)
//-----------------------------------------------------
CreateThread（ Introduction to six parameters ） Click to open the link
//-----------------------------------------------------
      If the creation is successful, the handle to the thread is returned , Otherwise return to NULL. After creating a new thread , The thread starts execution . But if dwCreationFlags Used in CREATE_SUSPENDED characteristic , Then the thread does not execute immediately , But hang up first , Wait until call ResumeThread Before starting the thread , In this process, you can call the following function to set the priority of the thread ：
       BOOL SetThreadPriority(HANDLE hThread,int nPriority);

    When the function of the calling thread returns , The thread terminates automatically .

    If you need to terminate during the execution of the thread, you can call the function ：

         VOID ExitThread(DWORD dwExitCode);

    If the thread is terminated outside the thread , Then you can call the following function ：

       BOOL TerminateThread(HANDLE hThread,DWORD dwExitCode);
But we should pay attention to it. : This function may cause system instability , And the resources occupied by threads are not released . therefore , In general , It is not recommended to use this function .
If the thread to be terminated is the last thread in the process , After the thread is terminated, the corresponding process should also be terminated .

2. Synchronization of threads

        In the thread body , If the thread is completely independent , There is no conflict with other threads in resource operations such as data access , You can program according to the usual single thread method . however , This is often not the case when multithreading , Threads often access some resources at the same time . It is inevitable to cause conflicts due to access to shared resources , To solve this thread synchronization problem ,Win32 API A variety of synchronization control objects are provided to help programmers solve shared resource access conflicts . Before introducing these synchronization objects, let's first introduce the wait function , Because this function is used for access control of all control objects .
         Win32 API Provides a set of wait functions that enable a thread to block its own execution . These functions generate signals in one or more synchronization objects in their parameters , Or it will return after the specified waiting time . When the waiting function does not return , The thread is in a wait state , At this time, the thread only consumes very little CPU Time . Using the wait function can ensure the synchronization of threads , It can also improve the operation efficiency of the program . The most commonly used wait function is ：

           DWORD WaitForSingleObject(HANDLE hHandle,DWORD dwMilliseconds);

The function WaitForMultipleObject It can be used to monitor multiple synchronization objects at the same time , The declaration of this function is ：

   DWORD WaitForMultipleObject(DWORD nCount,CONST HANDLE *lpHandles,BOOL bWaitAll,DWORD dwMilliseconds);

（1） Mutex object

    Mutex The state of an object is signaled only when it is not owned by any thread , And when it is owned, there is no signal .Mutex Object is very suitable for coordinating the mutually exclusive access of multiple threads to shared resources . You can use this object as follows ：

      First , Create a mutex object , Get the handle ：
         HANDLE CreateMutex();
    then , In front of areas where threads may conflict （ That is, before accessing shared resources ） call WaitForSingleObject, Pass the handle to the function , Request to occupy mutually exclusive objects ：
    dwWaitResult = WaitForSingleObject(hMutex,5000L);

    End of shared resource access , Release the occupation of mutex objects ：

    ReleaseMutex(hMutex);
    Mutex objects can only be occupied by one thread at a time , When the mutex object is occupied by a thread , If there is another way to occupy it , You must wait until the previous thread is released to succeed .

（2） Signal object
        Signal objects allow simultaneous access to shared resources of multiple threads , Specify the maximum number of threads that can be accessed simultaneously when creating an object . When a thread successfully requests access , The counter in the signal object is decremented by one , call ReleaseSemaphore After the function , The counter in the signal object is incremented by one . among , The counter value is greater than or equal to ０, But less than or equal to the maximum value specified at creation . If an application is creating a signal object , Set the initial value of its counter to ０, It blocks other threads , Protected resources . After initialization , call ReleaseSemaphore Function increases its counter to the maximum , Normal access . You can use this object as follows ：

First , Create a signal object ：
    HANDLE CreateSemaphore();
Or open a signal object ：

    HANDLE OpenSemaphore();

then , Call before the thread accesses the shared resource WaitForSingleObject.

        After the shared resource access is completed , The occupation of the signal object should be released ：
        ReleaseSemaphore();

（3） Event object

        Event object (Event) Is the simplest synchronization object , It includes two states of signal and no signal . Before a thread accesses a resource , Need to wait for an event to happen , At this time, the event object is the most appropriate . for example ： Only after the communication port buffer receives data , The monitoring thread is activated .

        The event object is CreateEvent Function . This function can specify the class of the event object and the initial state of the event . If it is a manual reset event , Then it always keeps the signal state , Until you use ResetEvent The function is reset to an event without a signal . If it's an automatic reset event , Then its state will automatically change to no signal after a single waiting thread is released . use SetEvent You can set the event object to a signaled state . When creating events , You can name objects , In this way, threads in other processes can use OpenEvent Function to open the event object handle with the specified name .
HANDLE   CreateEvent(
    　          LPSECURITY_ATTRIBUTES lpEventAttributes,　// SECURITY_ATTRIBUTES Structure pointer , for NULL
                BOOL bManualReset, 　// Manual / Automatically
            　          // TRUE： stay WaitForSingleObject Must be called manually after ResetEvent Clear the signal
            　          // FALSE： stay WaitForSingleObject after , The system automatically clears the event signal
                BOOL bInitialState, // The initial state
                LPCTSTR lpName // Name of event
         )

Use " event " The mechanism should pay attention to the following matters: ：
　　（1） If events are accessed across processes , The event must be named , When naming Events , Be careful not to conflict with other global named objects in the system namespace ;
　　（2） Whether the event should be automatically recovered ;
　　（3） The initial state of the event is set .

（4） Exclusion zone object

    When executing asynchronously in the exclusion zone , It can only share resource processing between threads of the same process . Although at this time, the above methods can be used , however , The method of using exclusion zone makes the efficiency of synchronous management higher .

Define a CRITICAL_SECTION The exclusion zone object of the structure , Call the following functions to initialize the object before the process uses :

     VOID InitializeCriticalSection(LPCRITICAL_SECTION);

When a thread uses exclusion zones , Call function ：EnterCriticalSection perhaps TryEnterCriticalSection;

When it is required to occupy 、 When exiting the exclusion zone , Call function LeaveCriticalSection, Release the occupation of exclusion zone objects , For other threads