_beginthread, _beginthreadex

骑猪看日落 2022-09-19 04:25 168阅读 0赞

# \_beginthread, \_beginthreadex #

*  [Visual Studio 2012][]
 *  [Visual Studio 2008][]
 *  [Visual Studio 2005][]
 *  [Visual Studio .NET 2003][]
 *  [Visual Studio 2013 ][Visual Studio 2013]

Creates a thread.

Copy

uintptr_t _beginthread( // NATIVE CODE
       void( __cdecl *start_address )( void * ),
       unsigned stack_size,
       void *arglist 
    );
    uintptr_t _beginthread( // MANAGED CODE
       void( __clrcall *start_address )( void * ),
       unsigned stack_size,
       void *arglist 
    );
    uintptr_t _beginthreadex( // NATIVE CODE
       void *security,
       unsigned stack_size,
       unsigned ( __stdcall *start_address )( void * ),
       void *arglist,
       unsigned initflag,
       unsigned *thrdaddr 
    );
    uintptr_t _beginthreadex( // MANAGED CODE
       void *security,
       unsigned stack_size,
       unsigned ( __clrcall *start_address )( void * ),
       void *arglist,
       unsigned initflag,
       unsigned *thrdaddr 
    );

Parameters

--------------------

start\_address

Start address of a routine that begins execution of a new thread. For \_beginthread, the calling convention is either [\_\_cdecl][cdecl] (for native code) or [\_\_clrcall][clrcall] (for managed code); for \_beginthreadex, it is either [\_\_stdcall][stdcall] (for native code) or [\_\_clrcall][clrcall] (for managed code).

stack\_size

Stack size for a new thread or 0.

Arglist

Argument list to be passed to a new thread or NULL.

Security

Pointer to a [ SECURITY\_ATTRIBUTES][SECURITY_ATTRIBUTES] structure that determines whether the returned handle can be inherited by child processes. If NULL, the handle cannot be inherited. Must be NULL for Windows 95 applications.

Initflag

Initial state of a new thread (0 for running or CREATE\_SUSPENDED for suspended); use [ ResumeThread][ResumeThread] to execute the thread.

Thrdaddr

Points to a 32-bit variable that receives the thread identifier. Might be NULL, in which case it is not used.

Return Value

--------------------

If successful, each of these functions returns a handle to the newly created thread; however, if the newly created thread exits too quickly, \_beginthread might not return a valid handle (see the discussion in the Remarks section). \_beginthread returns -1L on an error, in which case errno is set to EAGAIN if there are too many threads, to EINVAL if the argument is invalid or the stack size is incorrect, or to EACCES in the case of insufficient resources (such as memory). \_beginthreadex returns 0 on an error, in which case errno and \_doserrno are set.

If startaddress is NULL, the invalid parameter handler is invoked, as described in [Parameter Validation][]. If execution is allowed to continue, these functions set errno to EINVAL and return -1.

For more information about these and other return codes, see [ \_doserrno, errno, \_sys\_errlist, and \_sys\_nerr][_doserrno_ errno_ _sys_errlist_ and _sys_nerr].

For more information about uintptr\_t, see [ Standard Types][Standard Types].

Remarks

--------------------

The \_beginthread function creates a thread that begins execution of a routine at start\_address. The routine at  start\_address must use the \_\_cdecl (for native code) or \_\_clrcall (for managed code) calling convention and should have no return value. When the thread returns from that routine, it is terminated automatically. For more information about threads, see [ Multithreading][Multithreading].

\_beginthreadex resembles the Win32 [ CreateThread][CreateThread] API more closely than \_beginthread does. \_beginthreadex differs from \_beginthread in the following ways:

*  \_beginthreadex has three additional parameters: initflag, security, and threadaddr. The new thread can be created in a suspended state, with a specified security (Windows NT only), and can be accessed using thrdaddr, which is the thread identifier.
 *  The routine at start\_address passed to \_beginthreadex must use the \_\_stdcall (for native code) or \_\_clrcall (for managed code) calling convention and must return a thread exit code.
 *  \_beginthreadex returns 0 on failure, rather than -1L.
 *  A thread created with \_beginthreadex is terminated by a call to \_endthreadex.

The \_beginthreadex function gives you more control over how the thread is created than \_beginthread does. The \_endthreadex function is also more flexible. For example, with \_beginthreadex, you can use security information, set the initial state of the thread (running or suspended), and get the thread identifier of the newly created thread. You are also able to use the thread handle returned by \_beginthreadex with the synchronization APIs, which you cannot do with \_beginthread.

It is safer to use \_beginthreadex than \_beginthread. If the thread generated by \_beginthread exits quickly, the handle returned to the caller of \_beginthread might be invalid or, worse, point to another thread. However, the handle returned by \_beginthreadex has to be closed by the caller of \_beginthreadex, so it is guaranteed to be a valid handle if \_beginthreadex did not return an error.

You can call [ \_endthread][_endthread] or [ \_endthreadex][_endthread] explicitly to terminate a thread; however, \_endthread or \_endthreadex is called automatically when the thread returns from the routine passed as a parameter. Terminating a thread with a call to endthread or \_endthreadex helps to ensure proper recovery of resources allocated for the thread.

\_endthread automatically closes the thread handle (whereas \_endthreadex does not). Therefore, when using \_beginthread and \_endthread, do not explicitly close the thread handle by calling the Win32 [CloseHandle][] API. This behavior differs from the Win32 [ExitThread][] API.

<table> 
 <tbody> 
  <tr> 
   <th><img title="Note" alt="Note" src="http://i.msdn.microsoft.com/areas/global/content/clear.gif"><strong>Note</strong></th> 
  </tr> 
  <tr> 
   <td> <p>For an executable file linked with Libcmt.lib, do not call the Win32 <span>ExitThread</span> API; this prevents the run-time system from reclaiming allocated resources. <span>_endthread</span> and <span>_endthreadex</span> reclaim allocated thread resources and then call <span>ExitThread</span>.</p> </td> 
  </tr> 
 </tbody> 
</table>

The operating system handles the allocation of the stack when either \_beginthread or \_beginthreadex is called; you do not need to pass the address of the thread stack to either of these functions. In addition, the stack\_size argument can be 0, in which case the operating system uses the same value as the stack specified for the main thread.

arglist is a parameter to be passed to the newly created thread. Typically it is the address of a data item, such as a character string. arglist can be NULL if it is not needed, but \_beginthread and \_beginthreadex must be provided with some value to pass to the new thread. All threads are terminated if any thread calls abort, exit, \_exit, or ExitProcess.

The locale of the new thread is inherited from its parent thread. If per thread locale is enabled by a call to [ \_configthreadlocale][_configthreadlocale] (either globally or for new threads only), the thread can change its locale independently from its parent by calling setlocale or \_wsetlocale. For more information, see [ Locale][Locale].

For mixed and pure code, \_beginthread and \_beginthreadex both have two overloads, one taking a native calling-convention function pointer, the other taking a \_\_clrcall function pointer. The first overload is not application domain-safe and never will be. If you are writing mixed or pure code you must ensure that the new thread enters the correct application domain before it accesses managed resources. You can do this, for example, by using [call\_in\_appdomain Function][call_in_appdomain Function]. The second overload is application domain-safe; the newly created thread will always end up in the application domain of the caller of \_beginthread or \_beginthreadex.

Requirements

--------------------

<table> 
 <tbody> 
  <tr> 
   <th> <p>Routine</p> </th> 
   <th> <p>Required header</p> </th> 
  </tr> 
  <tr> 
   <td> <p><span>_beginthread</span></p> </td> 
   <td> <p>&lt;process.h&gt;</p> </td> 
  </tr> 
  <tr> 
   <td> <p><span>_beginthreadex</span></p> </td> 
   <td> <p>&lt;process.h&gt;</p> </td> 
  </tr> 
 </tbody> 
</table>

For more compatibility information, see [ Compatibility][Compatibility] in the Introduction.

Libraries

--------------------

Multithreaded versions of the [ C run-time libraries][C run-time libraries] only.

To use  \_beginthread or \_beginthreadex, the application must link with one of the multithreaded C run-time libraries.

Example

--------------------

The following example uses \_beginthread and \_endthread.

Copy

// crt_BEGTHRD.C
    // compile with: /MT /D "_X86_" /c
    // processor: x86
    #include <windows.h>
    #include <process.h>    /* _beginthread, _endthread */
    #include <stddef.h>
    #include <stdlib.h>
    #include <conio.h>
    
    void Bounce( void *ch );
    void CheckKey( void *dummy );
    
    /* GetRandom returns a random integer between min and max. */
    #define GetRandom( min, max ) ((rand() % (int)(((max) + 1) - (min))) + (min))
    
    BOOL repeat = TRUE;     /* Global repeat flag and video variable */
    HANDLE hStdOut;         /* Handle for console window */
    CONSOLE_SCREEN_BUFFER_INFO csbi;    /* Console information structure */
    
    int main()
    {
        CHAR    ch = 'A';
    
        hStdOut = GetStdHandle( STD_OUTPUT_HANDLE );
    
        /* Get display screen's text row and column information. */
       GetConsoleScreenBufferInfo( hStdOut, &csbi );
    
        /* Launch CheckKey thread to check for terminating keystroke. */
        _beginthread( CheckKey, 0, NULL );
    
        /* Loop until CheckKey terminates program. */
        while( repeat )
        {
            /* On first loops, launch character threads. */
            _beginthread( Bounce, 0, (void *) (ch++)  );
    
            /* Wait one second between loops. */
            Sleep( 1000L );
        }
    }
    
    /* CheckKey - Thread to wait for a keystroke, then clear repeat flag. */
    void CheckKey( void *dummy )
    {
        _getch();
        repeat = 0;    /* _endthread implied */
    
    }
    
    /* Bounce - Thread to create and and control a colored letter that moves
     * around on the screen.
     *
     * Params: ch - the letter to be moved
     */
    void Bounce( void *ch )
    {
        /* Generate letter and color attribute from thread argument. */
        char    blankcell = 0x20;
        char    blockcell = (char) ch;
        BOOL    first = TRUE;
       COORD   oldcoord, newcoord;
       DWORD   result;
    
    
        /* Seed random number generator and get initial location. */
        srand( _threadid );
        newcoord.X = GetRandom( 0, csbi.dwSize.X - 1 );
        newcoord.Y = GetRandom( 0, csbi.dwSize.Y - 1 );
        while( repeat )
        {
            /* Pause between loops. */
            Sleep( 100L );
    
            /* Blank out our old position on the screen, and draw new letter. */
            if( first )
                first = FALSE;
            else
             WriteConsoleOutputCharacter( hStdOut, &blankcell, 1, oldcoord, &result );
             WriteConsoleOutputCharacter( hStdOut, &blockcell, 1, newcoord, &result );
    
            /* Increment the coordinate for next placement of the block. */
            oldcoord.X = newcoord.X;
            oldcoord.Y = newcoord.Y;
            newcoord.X += GetRandom( -1, 1 );
            newcoord.Y += GetRandom( -1, 1 );
    
            /* Correct placement (and beep) if about to go off the screen. */
            if( newcoord.X < 0 )
                newcoord.X = 1;
            else if( newcoord.X == csbi.dwSize.X )
                newcoord.X = csbi.dwSize.X - 2;
            else if( newcoord.Y < 0 )
                newcoord.Y = 1;
            else if( newcoord.Y == csbi.dwSize.Y )
                newcoord.Y = csbi.dwSize.Y - 2;
    
            /* If not at a screen border, continue, otherwise beep. */
            else
                continue;
            Beep( ((char) ch - 'A') * 100, 175 );
        }
        /* _endthread given to terminate */
        _endthread();
    }

press any key to end

The following sample code demonstrates how you can use the thread handle returned by \_beginthreadex with the synchronization API [WaitForSingleObject][]. The main thread waits for the second thread to terminate before it continues. When the second thread calls \_endthreadex, it causes its thread object to go to the signaled state. This allows the primary thread to continue running. This cannot be done with \_beginthread and \_endthread, because \_endthread calls CloseHandle, destroying the thread object before it can be set to the signaled state.

Copy

// crt_begthrdex.cpp
    // compile with: /MT
    #include <windows.h>
    #include <stdio.h>
    #include <process.h>
    
    unsigned Counter; 
    unsigned __stdcall SecondThreadFunc( void* pArguments )
    {
        printf( "In second thread...\n" );
    
        while ( Counter < 1000000 )
            Counter++;
    
        _endthreadex( 0 );
        return 0;
    } 
    
    int main()
    { 
        HANDLE hThread;
        unsigned threadID;
    
        printf( "Creating second thread...\n" );
    
        // Create the second thread.
        hThread = (HANDLE)_beginthreadex( NULL, 0, &SecondThreadFunc, NULL, 0, &threadID );
    
        // Wait until second thread terminates. If you comment out the line
        // below, Counter will not be correct because the thread has not
        // terminated, and Counter most likely has not been incremented to
        // 1000000 yet.
        WaitForSingleObject( hThread, INFINITE );
        printf( "Counter should be 1000000; it is-> %d\n", Counter );
        // Destroy the thread object.
        CloseHandle( hThread );
    }

Creating second thread...
    In second thread...
    Counter should be 1000000; it is-> 1000000

CreateThread function
         
          
          
           
          
           Creates a thread to execute within the virtual address space of the calling process.
          
           To create a thread that runs in the virtual address space of another process, use the CreateRemoteThread function.
          
           Syntax
          
           C++ Copy 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
    );
    
     
          
           Parameters
          
           lpThreadAttributes [in, optional] A pointer to a SECURITY_ATTRIBUTES structure that determines whether the returned handle can be inherited by child processes. If lpThreadAttributes is NULL, the handle cannot be inherited. The lpSecurityDescriptor member of the structure specifies a security descriptor for the new thread. If lpThreadAttributes is NULL, the thread gets a default security descriptor. The ACLs in the default security descriptor for a thread come from the primary token of the creator. Windows XP:  The ACLs in the default security descriptor for a thread come from the primary or impersonation token of the creator. This behavior changed with Windows XP with SP2 and Windows Server 2003. For more information, see Remarks. dwStackSize [in] The initial size of the stack, in bytes. The system rounds this value to the nearest page. If this parameter is zero, the new thread uses the default size for the executable. For more information, see Thread Stack Size. lpStartAddress [in] A pointer to the application-defined function to be executed by the thread. This pointer represents the starting address of the thread. For more information on the thread function, see ThreadProc. lpParameter [in, optional] A pointer to a variable to be passed to the thread. dwCreationFlags [in] The flags that control the creation of the thread. Value Meaning 0 The thread runs immediately after creation. CREATE_SUSPENDED 0x00000004 The thread is created in a suspended state, and does not run until the ResumeThread function is called. STACK_SIZE_PARAM_IS_A_RESERVATION 0x00010000 The dwStackSize parameter specifies the initial reserve size of the stack. If this flag is not specified, dwStackSize specifies the commit size.   lpThreadId [out, optional] A pointer to a variable that receives the thread identifier. If this parameter is NULL, the thread identifier is not returned. 
          
           Return value
          
           If the function succeeds, the return value is a handle to the new thread.
          
           If the function fails, the return value is NULL. To get extended error information, call GetLastError.
          
           Note that CreateThread may succeed even if lpStartAddress points to data, code, or is not accessible. If the start address is invalid when the thread runs, an exception occurs, and the thread terminates. Thread termination due to a invalid start address is handled as an error exit for the thread's process. This behavior is similar to the asynchronous nature of CreateProcess, where the process is created even if it refers to invalid or missing dynamic-link libraries (DLLs).
          
           Remarks
          
           The number of threads a process can create is limited by the available virtual memory. By default, every thread has one megabyte of stack space. Therefore, you can create at most 2,048 threads. If you reduce the default stack size, you can create more threads. However, your application will have better performance if you create one thread per processor and build queues of requests for which the application maintains the context information. A thread would process all requests in a queue before processing requests in the next queue.
          
           The new thread handle is created with the THREAD_ALL_ACCESS access right. If a security descriptor is not provided when the thread is created, a default security descriptor is constructed for the new thread using the primary token of the process that is creating the thread. When a caller attempts to access the thread with the OpenThread function, the effective token of the caller is evaluated against this security descriptor to grant or deny access. 
          
           Windows XP:  If a security descriptor is not provided when the thread is created, a default security descriptor is constructed using the effective token of the thread. If the thread is impersonating another user, the thread's effective token is the impersonation token and the default security descriptor allows access only to the impersonation token's TokenDefaultDacl owner or members. If the thread is not impersonating another user, the thread's effective token is its primary token. This behavior changed starting with Windows XP with SP2 and Windows Server 2003. For more information, see Thread Security and Access Rights.
          
           The newly created thread has full access rights to itself when calling the GetCurrentThread function. 
          
           Windows Server 2003 and Windows XP:  The thread's access rights to itself are computed by evaluating the primary token of the process in which the thread was created against the default security descriptor constructed for the thread. If the thread is created in a remote process, the primary token of the remote process is used. As a result, the newly created thread may have reduced access rights to itself when calling GetCurrentThread. Some access rights including THREAD_SET_THREAD_TOKEN and THREAD_GET_CONTEXT may not be present, leading to unexpected failures. For this reason, creating a thread while impersonating another user is not recommended.
          
           If the thread is created in a runnable state (that is, if the CREATE_SUSPENDED flag is not used), the thread can start running before CreateThread returns and, in particular, before the caller receives the handle and identifier of the created thread.
          
           The thread execution begins at the function specified by the lpStartAddress parameter. If this function returns, the DWORD return value is used to terminate the thread in an implicit call to the ExitThread function. Use the GetExitCodeThread function to get the thread's return value.
          
           The thread is created with a thread priority of THREAD_PRIORITY_NORMAL. Use the GetThreadPriority and SetThreadPriority functions to get and set the priority value of a thread.
          
           When a thread terminates, the thread object attains a signaled state, satisfying any threads that were waiting on the object.
          
           The thread object remains in the system until the thread has terminated and all handles to it have been closed through a call to CloseHandle.
          
           The ExitProcess, ExitThread, CreateThread, CreateRemoteThread functions, and a process that is starting (as the result of a call by CreateProcess) are serialized between each other within a process. Only one of these events can happen in an address space at a time. This means that the following restrictions hold:
          
           During process startup and DLL initialization routines, new threads can be created, but they do not begin execution until DLL initialization is done for the process. Only one thread in a process can be in a DLL initialization or detach routine at a time. ExitProcess does not complete until there are no threads in their DLL initialization or detach routines. 
          
           A thread in an executable that calls the C run-time library (CRT) should use the _beginthreadex and _endthreadex functions for thread management rather than CreateThread and ExitThread; this requires the use of the multithreaded version of the CRT. If a thread created using CreateThread calls the CRT, the CRT may terminate the process in low-memory conditions.

[Visual Studio 2012]: http://msdn.microsoft.com/en-us/library/kdzttdcb%28v=vs.110%29.aspx
[Visual Studio 2008]: http://msdn.microsoft.com/en-us/library/kdzttdcb%28v=vs.90%29.aspx
[Visual Studio 2005]: http://msdn.microsoft.com/en-us/library/kdzttdcb%28v=vs.80%29.aspx
[Visual Studio .NET 2003]: http://msdn.microsoft.com/en-us/library/kdzttdcb%28v=vs.71%29.aspx
[Visual Studio 2013]: http://msdn.microsoft.com/en-us/library/kdzttdcb%28v=vs.120%29.aspx
[cdecl]: http://msdn.microsoft.com/en-us/library/zkwh89ks%28v=vs.100%29.aspx
[clrcall]: http://msdn.microsoft.com/en-us/library/ec7sfckb%28v=vs.100%29.aspx
[stdcall]: http://msdn.microsoft.com/en-us/library/zxk0tw93%28v=vs.100%29.aspx
[SECURITY_ATTRIBUTES]: http://msdn.microsoft.com/en-us/library/aa379560%28v=vs.100%29.aspx
[ResumeThread]: http://msdn.microsoft.com/en-us/library/cc429320.aspx
[Parameter Validation]: http://msdn.microsoft.com/en-us/library/ksazx244%28v=vs.100%29.aspx
[_doserrno_ errno_ _sys_errlist_ and _sys_nerr]: http://msdn.microsoft.com/en-us/library/t3ayayh1%28v=vs.100%29.aspx
[Standard Types]: http://msdn.microsoft.com/en-us/library/323b6b3k%28v=vs.100%29.aspx
[Multithreading]: http://msdn.microsoft.com/en-us/library/172d2hhw%28v=vs.100%29.aspx
[CreateThread]: http://msdn.microsoft.com/en-us/library/ms682453%28v=vs.100%29.aspx
[_endthread]: http://msdn.microsoft.com/en-us/library/hw264s73%28v=vs.100%29.aspx
[CloseHandle]: http://msdn.microsoft.com/en-us/library/cc429605.aspx
[ExitThread]: http://msdn.microsoft.com/en-us/library/cc429100.aspx
[_configthreadlocale]: http://msdn.microsoft.com/en-us/library/26c0tb7x%28v=vs.100%29.aspx
[Locale]: http://msdn.microsoft.com/en-us/library/wyzd2bce%28v=vs.100%29.aspx
[call_in_appdomain Function]: http://msdn.microsoft.com/en-us/library/ms177099%28v=vs.100%29.aspx
[Compatibility]: http://msdn.microsoft.com/en-us/library/sk54f3f5%28v=vs.100%29.aspx
[C run-time libraries]: http://msdn.microsoft.com/en-us/library/abx4dbyh%28v=vs.100%29.aspx
[WaitForSingleObject]: http://msdn.microsoft.com/en-us/library/cc429427.aspx