Win32进程线程（笔记备忘）

最新推荐文章于 2023-03-19 20:33:19 发布

xiaohuangcat

最新推荐文章于 2023-03-19 20:33:19 发布

阅读量1.4k

点赞数

分类专栏： c/c++

本文链接：https://blog.youkuaiyun.com/xiaohuangcat/article/details/16337245

版权

c/c++ 专栏收录该内容

26 篇文章

订阅专栏

本文详细介绍了Win32进程线程的相关知识，包括如何获取进程ID和句柄、如何打开进程、进程的使用（如创建进程、打开进程、结束进程、等候进程结束）、Windows作业的使用以及线程的创建、结束、挂起与执行。同时，文章还讨论了线程局部存储TLS的使用，展示了如何保证每个线程中数据的独特性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Win32进程

进程的信息
1 进程ID和句柄
GetCurrentProcessID 获取进程的ID
GetCurrentProcess 获取进程的句柄,
返回值为-1,是当前进程的伪句柄.
如果想获取当前进程的实际句柄
需要使用OpenProcess函数.
2 打开进程
HANDLE OpenProcess(
DWORD dwDesiredAccess, //访问模式
BOOL bInheritHandle, //继承标识
DWORD dwProcessId //进程ID
);
返回进程的句柄

void ProcInfo()
{
DWORD nID = GetCurrentProcessId();//当前进程ID
HANDLE hHproc =GetCurrentProcess();//返回值为-1，为当前进程句柄,伪句柄,但是可用.
HANDLE hHProc2 = OpenProcess(PROCESS_ALL_ACCESS, FALSE, nID);//获取当前进程的真正句柄
printf("%d, %p, %p\n",nID, hHproc,hHProc2);

}
3 获取进程的所使用的所有模块(EXE或DLL)
使用PSAPI函数.
BOOL EnumProcessModules(
HANDLE hProcess,//进程句柄
HMODULE * lphModule,//模块的数组
DWORD cb, //数组的长度
LPDWORD lpcbNeeded //获取到数据的字节数
);

四进程的使用
1 创建进程
WinExec 16位,现在不使用
ShellExecute 执行打开文件等操作.
CreateProcess 执行一个EXE可执行文件.创建
一个进程以及它的主线程.
BOOL CreateProcess(
LPCTSTR lpApplicationName,
//应用程序路径名
LPTSTR lpCommandLine, //命令行
LPSECURITY_ATTRIBUTES lpProcessAttributes,
//进程安全属性
LPSECURITY_ATTRIBUTES lpThreadAttributes,
//线程安全属性
BOOL bInheritHandles, //句柄继承标识
DWORD dwCreationFlags, //创建标识
LPVOID lpEnvironment, //环境块
LPCTSTR lpCurrentDirectory,//当前目录
LPSTARTUPINFO lpStartupInfo,//启动参数
LPPROCESS_INFORMATION lpProcessInformation
//进程信息
);
当进程创建成功,可以从进程信息中获取创建
好的进程句柄\ID等.
如果执行程序是16的程序,那么只能使用
lpCommandLine设置执行程序路径.

//打开扫雷游戏

void Create()
{
STARTUPINFO si = { 0 };
PROCESS_INFORMATION pi = { 0 };//进程信息保存在此
si.cb = sizeof(si);
CreateProcess("C:\\WINDOWS\\system32\\winmine.exe",NULL, NULL, NULL, FALSE,0, NULL,NULL,&si,&pi);
}

printf("hProcess :%p \n",pi.hProcess);
printf("hThread :%p \n",pi.hThread);//主线程句柄
printf("dwProcessId :%d \n",pi.dwProcessId);
printf("dwThreadId :%d \n",pi.dwThreadId);
2 打开进程
OpenProcess
3 结束进程
VOID ExitProcess( UINT uExitCode );
BOOL TerminateProcess(
HANDLE hProcess, //进程句柄
UINT uExitCode ); //结束代码

void f_TerminateProcess(DWORD nID)
{
//打开进程获取句柄
HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS,FALSE,nID);
//通过句柄结束程序
TerminateProcess(hProc,0);
}
4 等候进程结束
DWORD WaitForSingleObject(
HANDLE hHandle, //等候的句柄
DWORD dwMilliseconds );//等候的时间,毫秒
阻塞函数,当运行时,会在等候的时间的时间内,
等待句柄的信号.

void f_Wait()
{
STARTUPINFO si = { 0 };
PROCESS_INFORMATION pi = { 0 };
si.cb = sizeof(si);
CreateProcess("C:\\WINDOWS\\System32\\Winmine.exe",NULL,NULL,NULL,FALSE,0,NULL,NULL,&si,&pi);
printf("开启扫雷!\n");
WaitForSingleObject(pi.hProcess,INFINITE);//无限制等待
printf("扫雷结束!\n");
}

五 Windows作业(Job)

1 Windows作业
实际是一个进程组. 可以对作业设置权限,一旦
进程加入到作业之内,进程的权限将被作业限制.

2 作业的使用
需要NT5.0以上支持,所有在Windows.h前定义
#define _WIN32_WINNT 0x0500
2.1 创建一个作业
HANDLE CreateJobObject(
LPSECURITY_ATTRIBUTES lpJobAttributes,
// 安全属性
LPCTSTR lpName ); //名称
返回创建的Job句柄
2.2 设置作业权限
BOOL SetInformationJobObject(
HANDLE hJob,//Job句柄
JOBOBJECTINFOCLASS JobObjectInformationClass,
//Job权限的类型
LPVOID lpJobObjectInformation,
//类型所对应的数据结构的地址
DWORD cbJobObjectInformationLength
//类型所对应的数据结构的长度
);
2.3 将进程加入作业
BOOL AssignProcessToJobObject(
HANDLE hJob, //作业句柄
HANDLE hProcess );//进程句柄
2.4 关闭作业
CloseHandle
2.5 结束作业
使用TerminateJobObject结束作业.
但是并不是所有情况下,作业内的进程
都能被结束.

//用画图程序测试，只能读写，无法复制和黏贴、剪切,即使程序关闭，打开的画图程序依旧无法执行上述功能
//需要NT5.0以上支持，所以

#define _WIN32_WINNT 0x0500
#include <windows.h>
void Job()
{
HANDLE hJob = CreateJobObject(NULL, "MyJob");//创建job
//设置权限
JOBOBJECT_BASIC_UI_RESTRICTIONS ui = { 0 };
ui.UIRestrictionsClass = JOB_OBJECT_UILIMIT_READCLIPBOARD|JOB_OBJECT_UILIMIT_WRITECLIPBOARD;
SetInformationJobObject(hJob, JobObjectBasicUIRestrictions, &ui, sizeof(ui));
//创建进程
HANDLE hProc = Create("c:\\WINDOWS\\system32\\mspaint.exe");
//将进程加入作业
AssignProcessToJobObject(hJob,hProc);
getchar();

TerminateJobObject(hJob, 0);//执行此步骤，画图程序被关闭,但是并不是所有情况下，作业内的进程都能被结束。
//关闭job
CloseHandle(hJob);

}
六 Windows线程

1 Windows线程
Windows进程中可以执行代码的实体,Windows
系统可以调度的执行代码.一个进程中至少有
一个或多个线程. 每个线程是进程的一个任务
分支.

2 线程的特点
2.1 每个线程有一个ID.
2.2 每个线程有自己的安全属性
2.3 每个线程有自己的内存栈.

3 进程和线程多任务
多进程实现的多任务: 由于进程地址空间
是属于各自私有, 内存和资源不能共享.
多线程实现的多任务: 由于线程都是位于
同一个进程的地址空间,内存和资源可以
共享.

4 线程的执行
线程的执行方式采用轮询方式执行.
A -> B -> A -> B.....

七线程的使用

1 定义线程处理函数
DWORD WINAPI ThreadProc(
LPVOID lpParameter ); //线程参数
2 创建线程
HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes,
//安全属性
DWORD dwStackSize, //初始化栈的大小,缺省为0
LPTHREAD_START_ROUTINE lpStartAddress,
//线程的函数指针
LPVOID lpParameter, //线程参数
DWORD dwCreationFlags, //创建方式
LPDWORD lpThreadId //返回线程ID
);
返回值是创建好的线程的句柄.
3 结束线程
ExitThread
TerminateThread
4 线程挂起和执行
挂起线程
DWORD SuspendThread( HANDLE hThread );
执行线程
DWORD ResumeThread( HANDLE hThread );
5 等候线程的结束
可以使用 WaitForSingleObject 等候线程的
结束。
6 关闭线程句柄
CloseHandle

DWORD WINAPI ThreadProc1(LPVOID pParam)
{
DWORD nValue = DWORD(pParam);
printf("nValue:%d \n",nValue);
int n = 10;
while( n--)
{
printf("thread1-------\n");
Sleep(1000);
}
return 0;
}

DWORD WINAPI ThreadProc2(LPVOID pParam)
{
while(1)
{
printf("thread2-------\n");
Sleep(1000);
}
return 0;
}

void Create()
{
DWORD nThreadID = 0;
DWORD nThreadID2 = 0;
DWORD nValue = 100;
HANDLE hThread = CreateThread(NULL, 0, ThreadProc1, LPVOID(nValue), CREATE_SUSPENDED, &nThreadID);//线程挂起，但是句柄和id已经分配
printf("threadId:%d , hThread:%p \n",nThreadID,hThread);
ResumeThread(hThread);//激活线程1
WaitForSingleObject(hThread,INFINITE);//等待线程1结束之后，线程2开始执行
HANDLE hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, &nThreadID2);//创建一个立即执行的线程
printf("threadId2:%d , hThread2:%p \n",nThreadID2,hThread2);
SuspendThread(hThread2);//挂起线程2

CloseHandle(hThread2);//关闭线程不代表关闭线程，只是释放句柄资源，线程任可以继续执行,用TerminateThread，线程会结束.
}

八线程局部存储 Thread Local Storage

1 由于多个线程使用同一个变量，各个线程
都对变量进行操作，那么变量的值会被不同
线程操作覆盖。

通常变量A <-- 线程A
<-- 线程B

TLS 变量A <-- 线程A
变量A <-- 线程B

2 TLS的使用
2.1 使用关键字 __declspec(thread)
__declspec(thread) CHAR * g_pszText2 = NULL;
2.2 TLS相关API
TlsAlloc
TlsSetValue
TlsGetValue
TlsFree

CHAR* g_pData = NULL;
__declspec(thread) CHAR* g_pData2 = NULL;//保证每个线程中的数据唯一,每个线程中产生g_pData2的一个拷贝

void Print()
{
printf(g_pData2);
}

DWORD WINAPI ThreadProc1(LPVOID pParam)
{

CHAR* pTmp = (CHAR*)pParam;
g_pData2 = (CHAR*)malloc(100);
strcpy(g_pData2 , pTmp);
while (1)
{
Print();
Sleep(1000);
}

return 0;
}

void Create()
{
DWORD nThread = 0;
CHAR szText1[] = "Thread1 -------\n";
HANDLE hThread = CreateThread(NULL, 0, ThreadProc1, LPVOID(szText1), 0, &nThread);

CHAR szText2[] = "Thread2 --22----\n";
HANDLE hThread2 = CreateThread(NULL, 0, ThreadProc1, LPVOID(szText2), 0, &nThread);

CHAR szText3[] = "Thread ---33333----\n";
HANDLE hThread3 = CreateThread(NULL, 0, ThreadProc1, LPVOID(szText3), 0, &nThread);

getchar();
}

//Tls使用

// ThreadTls2.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "windows.h"
#include "stdlib.h"

CHAR* g_pszText = NULL;
DWORD g_nTlsIndex = 0;

void Print()
{
printf("g_pszText:%s \n",g_pszText);
//取出索引中的值g_pszText;
CHAR* pszText = (CHAR*)TlsGetValue(g_nTlsIndex);
printf("Tls:%s \n",pszText);
}

DWORD WINAPI ThreadProc(LPVOID pParam)
{
CHAR* pTmp = (CHAR*)pParam;
g_pszText = (CHAR*)malloc(100);
strcpy(g_pszText, pTmp);
//设置索引中的值
TlsSetValue(g_nTlsIndex, g_pszText);
while (1)
{
Print();
Sleep(1000);
}
}

void Create()
{
DWORD nThread = 0;
CHAR Text[] = "ThreadProc-----------------";
HANDLE hThread = CreateThread(NULL, 0,ThreadProc,LPVOID(Text), 0, &nThread);

CHAR Text2[] = "ThreadProc2-----------------";
hThread = CreateThread(NULL, 0,ThreadProc,LPVOID(Text2), 0, &nThread);

WaitForSingleObject(hThread, INFINITE);
}

int main(int argc, char* argv[])
{
//创建索引
g_nTlsIndex = TlsAlloc();
Create();

//释放Tls索引
TlsFree(g_nTlsIndex);
//printf("Hello World!\n");
return 0;
}