CreateThread function (processthreadsapi.

h) | Microsoft Docs

CreateThread function
12/04/2018 • 5 minutes to read
In this article
Syntax
Parameters
Return Value
Remarks
Requirements
See Also

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 CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes,
SIZE_T dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
__drv_aliasesMem LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
);

Parameters
lpThreadAttributes

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.

1 of 6
CreateThread function (processthreadsapi.h) | Microsoft Docs

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.

dwStackSize

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

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

A pointer to a variable to be passed to the thread.

dwCreationFlags

The flags that control the creation of the thread.

Value Meaning

The thread runs immediately after creation.

0

The thread is created in a suspended state, and

CREATE_SUSPENDED
does not run until the ResumeThread function is
0x00000004 called.

The dwStackSize parameter specifies the initial

STACK_SIZE_PARAM_IS_A_RESERVATION
reserve size of the stack. If this flag is not
0x00010000
specified, dwStackSize specifies the commit size.

lpThreadId

A pointer to a variable that receives the thread identifier. If this parameter is NULL, the

2 of 6
CreateThread function (processthreadsapi.h) | Microsoft Docs

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.

The newly created thread has full access rights to itself when calling the
GetCurrentThread function.

Windows Server 2003:  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

3 of 6
CreateThread function (processthreadsapi.h) | Microsoft Docs

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

4 of 6
CreateThread function (processthreadsapi.h) | Microsoft Docs

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.

Windows Phone 8.1: This function is supported for Windows Phone Store apps on
Windows Phone 8.1 and later.

Windows 8.1 and Windows Server 2012 R2: This function is supported for Windows

Store apps on Windows 8.1, Windows Server 2012 R2, and later.

Examples

For an example, see Creating Threads.

Requirements
   

Minimum Windows XP [desktop apps | UWP apps]

supported client

Minimum Windows Server 2003 [desktop apps | UWP apps]

supported server

Target Platform Windows

Header processthreadsapi.h (include Windows Server 2003, Windows Vista,

Windows 7, Windows Server 2008 Windows Server 2008 R2, Windows.h)

Library Kernel32.lib; WindowsPhoneCore.lib on Windows Phone 8.1

DLL Kernel32.dll; KernelBase.dll on Windows Phone 8.1

See Also
CloseHandle

CreateProcess

5 of 6
CreateThread function (processthreadsapi.h) | Microsoft Docs

CreateRemoteThread

ExitProcess

ExitThread

GetExitCodeThread

GetThreadPriority

Process and Thread Functions

ResumeThread

SECURITY_ATTRIBUTES

SetThreadPriority

SuspendThread

ThreadProc

Threads

6 of 6