win32day14-进程/作业/线程
Posted 吴英强
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了win32day14-进程/作业/线程相关的知识，希望对你有一定的参考价值。
Windows进程
1 Windows进程
进程一个容器，包含了应用程序实例的各种资源。Windows多任务的操作系统，因此可以
同时执行多个进程。
2 Windows进程的一些特点
2.1 进程中包含了执行代码等资源。
2.2 进程都具有私有的地址空间。
2.3 每个进程都有一个ID，标识进程。
2.4 每个进程都有自己的安全属性
2.5 至少要包含一个可以执行的线程。
进程的环境
1 环境信息的获取
获取：
LPVOID GetEnvironmentStrings(VOID)
返回值是获取到的所有环境信息
释放：
BOOL FreeEnvironmentStrings(
LPTSTR lpszEnvironmentBlock )
2 环境变量的获取和设置
获取：
DWORD GetEnvironmentVariable(
LPCTSTR lpName, //变量名称
LPTSTR lpBuffer, //数据BUFF
DWORD nSize //BUFF的长度
);
返回值是获取到的字符串的长度
设置：
BOOL SetEnvironmentVariable(
LPCTSTR lpName, //变量名称
LPCTSTR lpValue //变量的值
);
进程的信息
1 进程ID和句柄
GetCurrentProcessID 获取进程的ID
GetCurrentProcess 获取进程的句柄,
返回值为-1,是当前进程的伪句柄.
如果想获取当前进程的实际句柄
需要使用OpenProcess函数.
2 打开进程HANDLE OpenProcess(
DWORD dwDesiredAccess, //访问模式
BOOL bInheritHandle, //继承标识
DWORD dwProcessId //进程ID
);
返回进程的句柄
3 获取进程的所使用的所有模块(EXE或DLL)
使用PSAPI函数.
BOOL EnumProcessModules(
HANDLE hProcess,//进程句柄
HMODULE * lphModule,//模块的数组
DWORD cb, //数组的长度
LPDWORD lpcbNeeded //获取到数据的字节数
);
// ProcBase.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include "windows.h"
#include "../psapi/psapi.h"
#pragma comment( lib, "../psapi/psapi.lib" )
void ProcModule( )
printf( "All Modules\\n" );
//当前进程句柄
HANDLE hProc = GetCurrentProcess( );
//获取模块句柄
HMODULE hModules[256] = 0 ;
DWORD nNeed = 0;
EnumProcessModules( hProc, hModules,
256, &nNeed );
//计算获取到句柄数量
DWORD nCount = nNeed / sizeof(HMODULE);
for( DWORD nIndex=0; nIndex<nCount; nIndex++ )
//获取模块的文件名及路径
CHAR szPath[MAX_PATH] = 0 ;
GetModuleFileNameEx( hProc,
hModules[nIndex], szPath, MAX_PATH );
//打印
printf( "\\t%d: %p, %s\\n", nIndex+1,
hModules[nIndex], szPath );
void ProcInfo( )
//获取进程ID
DWORD nID = GetCurrentProcessId( );
//获取进程句柄(-1,伪句柄)
HANDLE hProc = GetCurrentProcess( );
printf( "Process ID: %d\\n", nID );
printf( "Process Handle: %p\\n", hProc );
//根据进程ID获取进程实际句柄
hProc = OpenProcess( PROCESS_ALL_ACCESS,
FALSE, nID );
printf( "Process Handle: %p\\n", hProc );
int main(int argc, char* argv[])
ProcInfo( );
ProcModule( );
return 0;
进程的使用
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设置执行程序路径.
2 打开进程
OpenProcess
3 结束进程
VOID ExitProcess( UINT uExitCode );
BOOL TerminateProcess(
HANDLE hProcess, //进程句柄
UINT uExitCode ); //结束代码
4 等候进程结束
DWORD WaitForSingleObject(
HANDLE hHandle, //等候的句柄
DWORD dwMilliseconds );//等候的时间,毫秒
阻塞函数,当运行时,会在等候的时间的时间内,
等待句柄的信号.
// ProcUse.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include "conio.h"
#include "windows.h"
void Create( )
STARTUPINFO si = 0 ;
PROCESS_INFORMATION pi = 0 ;
si.cb = sizeof( si );
si.dwFlags = STARTF_USESIZE;
si.dwXSize = 100;
si.dwYSize = 200;
//创建进程
CreateProcess( "ChildProc.exe",
"\\"Hello Child\\"",
NULL, NULL, FALSE,
CREATE_NEW_CONSOLE,
NULL, NULL, &si, &pi );
//输出信息
printf( "Process Handle: %p\\n", pi.hProcess );
printf( "Process ID: %d\\n", pi.dwProcessId );
printf( "Thread Handle: %p\\n", pi.hThread );
printf( "Thread ID: %d\\n", pi.dwThreadId );
void Terminate( DWORD dwProcID )
//打开进程获取句柄
HANDLE hProc = OpenProcess(
PROCESS_ALL_ACCESS, FALSE,
dwProcID );
//结束进程
TerminateProcess( hProc, 0 );
void 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( "Winmine is running\\n" );
//等候进程结束
WaitForSingleObject( pi.hProcess,
INFINITE );
printf( "Winmine is stop\\n" );
int main(int argc, char* argv[])
//Create( );
//Terminate( 244 );//打开一个程序，查看程序的进程号。终止此进程。
Wait( );
getch( );
return 0;
// ChildProc.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include "conio.h"
int main(int argc, char* argv[])
printf("ChlidProc: Hello World!\\n");
printf("ChlidProc: argc=%d\\n", argc );
printf("ChlidProc: argv=%s\\n", argv[0] );
getch( );
return 0;
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结束作业.
但是并不是所有情况下,作业内的进程
都能被结束.
// WinJob.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include "conio.h"
#define _WIN32_WINNT 0x0500
#include "windows.h"
HANDLE Create( LPSTR pszPath )
STARTUPINFO si = 0 ;
PROCESS_INFORMATION pi = 0 ;
si.cb = sizeof( si );
CreateProcess( pszPath,
NULL, NULL, NULL, FALSE, 0,
NULL, NULL, &si, &pi );
return pi.hProcess;
void Job( )
//创建Job对象
HANDLE hJob =
CreateJobObject( NULL, "MyJob" );
//设置权限
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 );
hProc = Create(
"c:\\\\windows\\\\system32\\\\mspaint.exe" );
AssignProcessToJobObject(
hJob, hProc );
getch( );
//结束作业
TerminateJobObject( hJob, 0 );
//关闭Job
CloseHandle( hJob );
int main(int argc, char* argv[])
Job( );
return 0;
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
// ThreadBase.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include "conio.h"
#include "windows.h"
DWORD WINAPI ThreadProc1( LPVOID pParam )
DWORD nValue = (DWORD)pParam;
for( int nIndex=0; nIndex<10; nIndex++ )
printf( "Thread Proc1-------%d\\n",
nValue );
Sleep( 1000 );
return 0;
DWORD WINAPI ThreadProc2( LPVOID pParam )
while( 1 )
printf( "-------Thread Proc2\\n" );
Sleep( 1000 );
return 0;
void Create( )
DWORD nValue = 100;
//创建一个挂起的线程
DWORD nThreadID = 0;
HANDLE hThread = CreateThread( NULL, 0,
ThreadProc1, (LPVOID)nValue,
CREATE_SUSPENDED, &nThreadID );
printf( "Thread 1 ID: %d\\n", nThreadID );
printf( "Thread 1 Handle: %p\\n", hThread );
//执行线程
ResumeThread( hThread );
//等候线程1结束
WaitForSingleObject( hThread, INFINITE );
CloseHandle( hThread );
//创建一个立刻执行的线程
hThread = CreateThread( NULL, 0,
ThreadProc2, NULL, 0, &nThreadID );
printf( "Thread 2 ID: %d\\n", nThreadID );
printf( "Thread 2 Handle: %p\\n", hThread );
//挂起线程
//SuspendThread( hThread );
CloseHandle( hThread );
int main(int argc, char* argv[])
Create( );
getch( );
return 0;
八 线程局部存储 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
// ThreadTls.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include "conio.h"
#include "stdlib.h"
#include "windows.h"
CHAR * g_pszText1 = NULL;
//使用关键字定义TLS变量
__declspec(thread) CHAR * g_pszText2 = NULL;
void Print( )
printf( "Text1: %s\\n", g_pszText1 );
printf( "Text2: %s\\n", g_pszText2 );
DWORD WINAPI PrintProc( LPVOID pParam )
CHAR * pszText = (CHAR *)pParam;
g_pszText1 = (CHAR *)malloc( 100 );
memset( g_pszText1, 0, 100 );
strcpy( g_pszText1, pszText );
g_pszText2 = (CHAR *)malloc( 100 );
memset( g_pszText2, 0, 100 );
strcpy( g_pszText2, pszText );
while( 1 )
Print( );
Sleep( 1000 );
return 0;
void Create( )
DWORD dwThread = 0;
CHAR szText1[] = "Thread 1----------";
HANDLE hThread = CreateThread( NULL,
0, PrintProc, szText1, 0, &dwThread );
CHAR szText2[] = "-----Thread 2-----";
hThread = CreateThread( NULL,
0, PrintProc, szText2, 0, &dwThread );
CHAR szText3[] = "----------Thread 3";
hThread = CreateThread( NULL,
0, PrintProc, szText3, 0, &dwThread );
getch( );
int main(int argc, char* argv[])
Create( );
return 0;
以上是关于win32day14-进程/作业/线程的主要内容，如果未能解决你的问题，请参考以下文章