In the system, a process mainly consists of two parts: the process kernel object and the process address space. The operating system manages processes through process kernel objects, and the process address space is used to maintain the resources required by the process: such as code, global variables, resource files, etc.
Then threads also have two parts: thread kernel object and thread stack. The operating system manages threads through thread kernel objects. The thread stack is used to maintain all function parameters and local variables required by threads when executing code.
The overhead of threads is much smaller than that of processes, so when performing multiple tasks concurrently, you should use multiple threads to solve the problem as much as possible, rather than use multiple processes to solve the problem.
Create thread
When the exe program starts, the operating system will create a main thread to execute the entry function (main function). By calling the corresponding function in the main thread, more threads can be created to execute tasks. passCreateThreadFunctions can create a thread.
HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes,//ThreadSafe Descriptor
SIZE_T dwStackSize,// The initial stack size, usually 0, means that the default size is used.
LPTHREAD_START_ROUTINE lpStartAddress,// Function pointer to be executed by multithreads
__drv_aliasesMem LPVOID lpParameter, // Parameters passed to multithreads
DWORD dwCreationFlags,// Thread creation flag, usually 0, means execution immediately. CREATE_SUSPENDED means that the thread is not scheduled immediately after it is created.
LPDWORD lpThreadId // Pointer to the variable that receives the thread ID, usually NULL.
);The following is the sameCreateThreadSimple example code to create multithreading and execute a function.
#include <iostream>
#include <>
// Thread function
DWORD WINAPI ThreadFunction(LPVOID lpParam)
{
While (true)
{
std::cout << "Hello, World!" << std::endl;
Sleep(1000); // Sleep for 1 second
}
return 0;
}
int main()
{ // Create thread
HANDLE hThread = CreateThread(
NULL, // Default security attributes
0, // Default stack size
ThreadFunction, // Thread function
NULL, // Thread function parameters
0, // Create flag by default
NULL); // No thread ID is required
// Prevent the main thread from quitting immediately
WaitForSingleObject(hThread, INFINITE);
// Close the thread handle
CloseHandle(hThread);
return 0;
}Terminate thread
(1) Return normally through the function to be executed through the thread (it is recommended to use this method).
(2) By callingExitThreadThe function exits the thread, and it is generally not recommended to use this function.
(3) By callingTerminateThreadThis method is not generally recommended for functions to exit the thread.
(4) The process can be directly terminated and the execution of the thread can be indirectly terminated.
Creating thread two
We use the above codeCreateThreadThe function creates a thread, which is a function of Windows, not a function provided in the C/C++ library. We can use_beginthreadexFunction creation thread, through_endthreadexThe function ends the thread. This is my highly recommended and commonly used way to create threads._beginthreadexThe function prototype is as follows, andCreateThreadThe difference between function prototypes is not very large.
uintptr_t _beginthreadex(
void* _Security,//Thread safety descriptor
unsigned _StackSize,//The initial stack size of the thread, usually 0, means that the default size is used.
_beginthreadex_proc_type _StartAddress,//Pointer to the thread function, that is, the entry point of the thread.
void* _ArgList,// The argument passed to the thread function can be NULL.
unsigned _InitFlag,//Thread creation flag, usually 0.
unsigned* _ThrdAddr//Pointer to receive the variable of the thread ID, which can be NULL.
);The following is the use_beginthreadexand_endthreadexA simple example of .
#include <iostream>
#include <>
#include <>
// Thread function
unsigned __stdcall ThreadFunction(void* lpParam)
{
While (true)
{
std::cout << "Hello, World!" << std::endl;
Sleep(1000); // Sleep for 1 second
_endthreadex(0); // End thread
}
return 0;
}
int main()
{
// Create thread
uintptr_t hThread = _beginthreadex(
NULL, // Default security attributes
0, // Default stack size
ThreadFunction, // Thread function
NULL, // Thread function parameters
0, // Create flag by default
NULL); // No thread ID is required
// Prevent the main thread from quitting immediately
WaitForSingleObject((HANDLE)hThread, INFINITE);
// Close the thread handle
CloseHandle((HANDLE)hThread);
return 0;
}Get the handle of the thread
pass_beginthreadexorCreateThreadAfter the function creates a thread successfully, you can get the handle to the newly created thread. In addition, you can also passGetCurrentThreadFunction to get the currently running thread handle.
HANDLE hThreadHandle = GetCurrentThread();Can also be calledGetCurrentThreadIdGets the running thread ID.
DWORD id = GetCurrentThreadId();Pause and rerun threads
CallSuspendThreadFunctions andResumeThreadFunctions can pause or rerun threads. At the same time, when creating, you can pass the thread creation flagCREATE_SUSPENDED, it can also prevent the thread from running immediately.
SuspendThread(hThreadHandle);
ResumeThread(hThreadHandle);Thread sleep
By callingSleepFunctions can make the thread sleep, and the operating system will not allocate CPU time to the current thread. NoticeSleepThe unit of parameter of a function is milliseconds. Note: If you pass 0 to the parameter, it means that the operating system calls another thread, forcing the operating system to perform a thread context switch and execute other thread code.
Sleep(1000);Get thread context
Each thread has its own context, context records and the state of the thread's last execution, including register status, instruction pointer, stack information, function return address, etc. We can passGetThreadContextFunctions are used to obtain the context information of the thread. Of course, in general, applications rarely pay attention to this context information.
BOOL ret = GetThreadContext(hThreadHandle, px);Thread priority
The Windows operating system will assign each process a thread priority code of 0-31, and the application does not have to manually set this priority code. When the operating system allocates CPU time to each thread, it will allocate different CPU time to different threads from low to high according to different priority numbers. If there are no special needs, under normal circumstances, the multithread we create can use the default thread priority.
Windows provides six priority classes: idle, below normal, normal, above normal, high and real-time. Among them, normal is the process priority by default. Basically 99% of processes should use this priority.
The program can be passedSetThreadPriorityTo set the priority of the process, the prototype is as follows:
BOOL SetThreadPriority(
HANDLE hThread,
int nPriority
);The first parameterhThreadRepresents the thread handle, the second parameternPriorityIndicates the priority to be adjusted, there are 7 options. They are
(1) THREAD_PRIORITY_ABOVE_NORMAL: higher than normal
(2) THREAD_PRIORITY_BELOW_NORMAL: Lower than normal
(3), THREAD_PRIORITY_HIGHEST: Highest
(4), THREAD_PRIORITY_IDLE: Idle
(5), THREAD_PRIORITY_LOWEST: Minimum
(6), THREAD_PRIORITY_NORMAL: Normal
(7), THREAD_PRIORITY_TIME_CRITICAL: Real-time