进程与线程

进程：直观的讲就是任务管理器中我们看到的东西。

与内核对象句柄相似的，进程也有进程对象句柄，可以进行进程的各种操作如打开关闭。

每个进程都是独立的，在进程启动以后系统分配彼此独立的虚拟内存，此时进程会将其所有的代码等数据在虚拟内存中进行展开

进程本身不能执行代码，它是一种严谨的数据结构，用于进行管理相关工作。其在三环有一个结构叫做PEB，在0环有一个结构叫EPROCESS，这两个结构用于对进程进行管理工作。

一个进程可以有多个线程，它们存储在线程列表中。在如上的两个结构中都有一个项用于指向线程列表，而线程才是真正执行代码的东西

当进程启动时，主线程被启动，用于执行main函数

在单核处理器下，我们看到的多线程同时进行只是多线程在极短的时间内进行快速切换执行的假象，而在多核处理器下，每个核心都可以独立去执行单个线程，是真正意义上的多线程同时执行。

当主线程消失的时候，进程也随之销毁

在Windows下创建进程有多种形式，如WinExec()，system()等等，其本质是对CreateProcess()的封装

现我们通过一个完整的程序了解进程与线程

#include<Windows.h>
#include<iostream>
int main()
{
	//该结构体指定创建进程时的主窗口的窗口工作站，桌面，标准句柄和外观
	STARTUPINFO StartupInfo = { sizeof(STARTUPINFO) };//必须初始化该结构第一个成员cb，即该结构大小。利用sizeof是因为防止因Windows的更新迭代导致该结构发生变化导致结构大小错误
	//该结构体包含有关新创建的进程及其主线程的信息
	PROCESS_INFORMATION ProcessInformation;
	//创建进程
	BOOL bRet = CreateProcess(L"F:\\ChinaNet-EDU.exe",     //文件路径
		NULL,                                 //命令行参数
		NULL,                                 //进程安全属性
		NULL,                                 //主线程安全属性
		FALSE,                                //进程句柄是否可继承
		NULL,                                 //控制优先级类和进程的创建标志
		NULL,                                 //指向新进程的环境块的指针
		NULL,                                 //进程当前目录的完整路径
		&StartupInfo,                         //指向STARTUPINFO或STARTUPINFOA的指针
		&ProcessInformation                   //指向PROCESS_INFORMATION结构的指针
	);
	if (!bRet) {
		std::cout << "CreateProcess Failed!" << std::endl;
	}
	else {
		std::cout << "进程句柄：" << ProcessInformation.hProcess << std::endl;
		std::cout << "线程句柄：" << ProcessInformation.hThread << std::endl;
		std::cout << "进程ID：" << ProcessInformation.dwProcessId << std::endl;
		std::cout << "主线程ID：" << ProcessInformation.dwThreadId << std::endl;
		//CloseHandele(ProcessInformation.hThread);
		//CloseHandele(ProcessInformation.dwThreadId);//不使用句柄时，关闭
	}
	//关闭进程（只能关闭没有保护，即权限较低的进程）
	//TerminateProcess(ProcessInformation.hProcess, 0);
	//通过关闭主线程关闭进程
	TerminateThread(ProcessInformation.hThread, 0);
	//结束当前进程：
	ExitProcess(0);
	system("pause");
	return 0;
}

在上述程序中我们通过了进程句柄去结束我们自己的进程。但当我们想要结束不是我们自己创建的进程/线程时，我们可以通过任务管理器查找进程ID去获取进程句柄

#include<Windows.h>
#include<iostream>
int main()
{
    //如现在我们通过任务管理器得知一个进程ID:5340
    HANDLE hProcesss = OpenProcess
    (
        PROCESS_ALL_ACCESS,   //权限
        FALSE,                //可否继承
        5430                 //进程ID
  	)//获取进程句柄
    if(hProcess==NULL)//当无法打开该进程，即打开不了权限较高的进程时
    {
    	std::cout<<"OpenProcess Error Code:"<<GetLastError<<std::endl;
  	}
    TerminateProcess(hProcess,0);
	return 0;
}

进程快照

在实际的应用中，我们不可能去通过任务管理器去查找进程ID，因为太耗费时间。因此我们可以通过进程快照来获取我们需要的进程ID并进行接下来的操作

#include<Windows.h>
#include<iostream>
#include <TlHelp32.h> //需要包含的头文件
int main()
{  
  	//创建进程快照
    HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
	//拿到第一个进程信息
	PROCESSENTRY32 pe32 = { sizeof(PROCESSENTRY32) };
	BOOL bRet = Process32First(hSnap, &pe32);
	//遍历进程快照
    while(bRet) 
    {
		std::cout << pe32.szExeFile << ":" << lppe.th32ProcessID << std::endl;//打印进程名及ID
		//字符串比较
		if (strcmp(pe32.szExeFile, "ChinaNet-EDU.exe") == 0) //当遍历到我们想要打开的进程时
        { 
			//打开进程
			HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pe32.th32ProcessID);
			//关闭进程
			BOOL Ret = TerminateProcess(hProcess, 0);
			if (!Ret) 
            {
				std::cout<<"TerminateProcess："<<pe32.szExeFile<<"Failed Code :"<<std::endl;
			}
		}
		//继续找下一个进程
		bRet = Process32Next(hSnap, &lppe);
	}
    return 0;
}

线程的开关

//该程序有两个线程，一个主线程一个子线程
#include <iostream>
#include <Windows.h>
#include <TlHelp32.h>
DWORD ThreadCallBack(LPVOID lpThreadParameter) //此处是我们创建个一个子线程
{
	int i = 0;
	while (true)
	{
		std::cout << "Thread:" << i++ << std::endl;
		Sleep(1000);
	}
}
int main()
{
  	//用于接收线程ID
	DWORD dwThreadID;
	//创建线程
	HANDLE hThread = CreateThread(
		NULL,           //安全属性，结构体里面有一个成员，决定线程句柄是否可以继承
		NULL,           //堆栈大小，如果为NULL，则分配默认大小
		ThreadCallBack, //指向有线程执行的应用程序定义函数的指针
		NULL,           //指向由线程执行的应用程序传给线程的变量指针
		NULL,           //控制线程创建的标志：立即执行或挂起等状态
		&dwThreadID     //指向接收线程表示符的变量指针
	);
	int i = 0;
	while (true)
	{
		std::cout << "Main:" << i++ << std::endl;
		Sleep(1000);
	} 
	system("pause");
	return 0;
}

注意：当主线程关闭时，子线程也随之关闭

作业

1.实现线程快照功能

#include<Windows.h>
#include <iostream>
#include<TlHelp32.h>
int main()
{
    HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, NULL);
    if (hSnap == INVALID_HANDLE_VALUE)
    {
        std::cout << "CreateToolhelp32Snapshot failed" << std::endl;
        return FALSE;
    }
    THREADENTRY32 hThread = { sizeof(THREADENTRY32) };
    BOOL bRet = Thread32First(hSnap, &hThread);
    while (bRet)
    {
        std::cout << "ThreadID:" << hThread.th32ThreadID << std::endl;
        bRet = Thread32Next(hSnap, &hThread);
        if (bRet == FALSE)
        {
            std::cout << "线程快照打印完毕" << std::endl;
            CloseHandle(hSnap);
            return FALSE;
        }
    }
    return 0;
}

2.尝试线程的挂起与恢复

#include<Windows.h>
#include<iostream>
#include<thread>
void FirstThread()
{
	std::cout << "FirstThread线程开始" << std::endl;
	int i = 0;
	for (int i = 0; i < 10000; i++)
	{
		std::cout << "i = " << i << std::endl;
	}
}
int main()
{
	std::thread ThreadOne(FirstThread);
	SuspendThread(ThreadOne.native_handle());
	std::cout << "FirstThread被挂起" << std::endl;
	Sleep(3000);
	ResumeThread(ThreadOne.native_handle());
	std::cout << "FirstThread被唤起" << std::endl;
	ThreadOne.join();
	return 0;
}

3.使用MFC制作一个进程管理器（进程LIst）右键可以结束进程，可以打开线程列表（右键结束线程，挂起恢复线程）