Windows进程

进程是一个容器，包括程序运行须要的代码、数据、资源等信息，

windows进程的特点：

每一个进程都有自己的ID号

每一个进程都有自己的地址空间。进程之间无法訪问对方的地址空间。

每一个进程都有自己的安全属性

每一个进程至少包括一个线程。

获取和释放环境信息

GetEnvironmentStrings

FreeEnvironmentStrings

获取或设置 本程序的环境变量

GetEnvironmentVariable

SetEnvironmentVariable

演示样例：

char* env=(char*) GetEnvironmentStrings();

char* env2=env;

while(env2[0])

{

printf("%s\n",env2);

env2=env2+strlen(env2)+1;

}

FreeEnvironmentStrings(env);

SetEnvironmentVariable("abc","100");

char buf[10]={0};

GetEnvironmentVariable("abc",buf,256);

printf("%s\n",buf);





进程信息

1、进程ID

DWORD pid= GetCurrentProcessId();

2、进程句柄

HANDLE hpro=GetCurrentProcess();

3、启动进程

BOOL CreateProcess(

  LPCTSTR lpApplicationName,//应用程序名称

  LPTSTR lpCommandLine,//命令行參数

  LPSECURITY_ATTRIBUTES lpProcessAttributes, // SD

  LPSECURITY_ATTRIBUTES lpThreadAttributes,  // SD

  BOOL bInheritHandles,//是否能被子进程使用

  DWORD dwCreationFlags,//创建方式

  LPVOID lpEnvironment,//环境信息

  LPCTSTR lpCurrentDirectory,//当前文件夹

  LPSTARTUPINFO lpStartupInfo,//返回的：起始信息

  LPPROCESS_INFORMATION lpProcessInformation //返回的：进程信息

);

演示样例：

STARTUPINFO stinfo={0};

PROCESS_INFORMATION pi={0};

CreateProcess("C:/Windows/System32/calc.exe",0,NULL,NULL,TRUE,0,NULL,NULL,

&stinfo,&pi);

WaitForSingleObject(pi.hProcess,INFINITE);//等待信号（通常是进程结束才有信号）

printf("Processid=%d,handle=%d\n",pi.dwProcessId,pi.hProcess);

退出本进程

VOID ExitProcess(  UINT uExitCode//退出码

);

退出随意进程

BOOL TerminateProcess(  HANDLE hProcess, // handle to the process

  UINT uExitCode   // exit code for the process

);





通过进程ID获取进程句柄

HANDLE OpenProcess(

DWORD dwDesiredAccess,  // access flag

BOOL bInheritHandle,// handle inheritance option

 DWORD dwProcessId// process identifier

);

获取和关闭进程演示样例（进程ID为32）：

HANDLE calc=OpenProcess(PROCESS_ALL_ACCESS,FALSE,32);

TerminateProcess(calc,-1);

进程间的等候，等候 进程/线程 信号到来

（通常是进程结束才有信号）

DWORD WaitForSingleObject(

HANDLE hHandle,        // handle to object

DWORD dwMilliseconds   // time-out interval

);

windows线程

windows线程是能够运行的代码实例。系统是以线程为单位调度程序。

windows线程特点：

线程都有Id

线程具有自己的安全属性

线程有什么的内存栈

线程都有自己的寄存器信息

进程多任务：每一个进程都使用私有的地址空间。

线程多任务：进程内多个线程使用同一个地址空间。

线程处理函数：

DWORD WINAPI ThreadProc(

LPVOID lpParameter   // thread data

);

HANDLE CreateThread(

LPSECURITY_ATTRIBUTES lpThreadAttributes,// SD

SIZE_T dwStackSize, // 线程栈大小（默认1M）

LPTHREAD_START_ROUTINE lpStartAddress, // 线程处理函数

LPVOID lpParameter,  //传给线程处理函数的參数

DWORD dwCreationFlags, // creation option

LPDWORD lpThreadId //返回值：线程ID

);

dwCreationFlags:

0-创建之后马上运行

CREATE_SUSPENDED-创建之后挂起。不马上运行





//结束线程，与结束进程使用方法一样

TerminateThread(...)

ExitThread(...);

CloseHandle()//关闭线程句柄，不是结束线程

可用WaitForSingleObject()等候线程结束

挂起线程

DWORD SuspendThread(  HANDLE hThread   // handle to thread);

恢复线程

DWORD ResumeThread(  HANDLE hThread   // handle to thread);

演示样例：

DWORD CALLBACK TestProc1(LPVOID param)

{

char*txt=(char*)param;

while(1)

{

printf("%s\n",txt);

Sleep(1000);

}

}

DWORD CALLBACK TestProc2(LPVOID param)

{

char*txt=(char*)param;

while(1)

{

printf("%s\n",txt);

Sleep(1000);

}

}

void Thread()

{

DWORD tid=0;

char *txt="*************************";

HANDLE hthread1=CreateThread(NULL,0,TestProc1,txt,

0,&tid);

char *txt2="————————————";

HANDLE hthread2=CreateThread(NULL,0,TestProc2,txt2,

CREATE_SUSPENDED,&tid);

getchar();

SuspendThread(hthread1);//挂起

ResumeThread(hthread2);//恢复

}

获取线程ID和句柄，与进程操作类似：

GetCurrentThreadId

GetCurrentThread

OpenThread

进程演示样例代码：

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

//

#include "stdafx.h"

#include<STDIO.H>

#include<WINDOWS.H>

void winProc()

{

	char* env=(char*) GetEnvironmentStrings();

	char* env2=env;

	while(env2[0])

	{

		printf("%s\n",env2);

		env2=env2+strlen(env2)+1;

	}

	FreeEnvironmentStrings(env);

	SetEnvironmentVariable("abc","100");

	char buf[10]={0};

	GetEnvironmentVariable("abc",buf,256);

	printf("%s\n",buf);

	DWORD pid= GetCurrentProcessId();

	HANDLE hpro=GetCurrentProcess();

}

void CreateProc()

{

	STARTUPINFO stinfo={0};

	PROCESS_INFORMATION pi={0};

	CreateProcess("C:/Windows/System32/calc.exe",0,NULL,NULL,TRUE,0,NULL,NULL,

		&stinfo,&pi);

	WaitForSingleObject(pi.hProcess,INFINITE);//等待信号（通常是进程结束才有信号）

	printf("Processid=%d,handle=%d\n",pi.dwProcessId,pi.hProcess);

}

void KillProc()

{

	HANDLE calc=OpenProcess(PROCESS_ALL_ACCESS,FALSE,32);

	TerminateProcess(calc,-1);

}

int main(int argc, char* argv[])

{

	//winProc();

	CreateProc();

	//KillProc();

	return 0;

}

线程与信号量使用演示样例（信号量是一种线程同步技术）：

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

//

#include "stdafx.h"

#include<stdio.h>

#include<windows.h>

char g_txt[256];

char g_txt2[256];

CRITICAL_SECTION cs={0};

HANDLE g_hSem=0;

DWORD CALLBACK PrintProc(LPVOID param)

{

	char buf[10]={0};

	while(1)

	{

		WaitForSingleObject(g_hSem,INFINITE);//有信号才运行

		ZeroMemory(buf,sizeof(buf));

		GetEnvironmentVariable("exit",buf,sizeof(buf));

		if(strcmp(buf,"1")==0) break;

		printf("**************************\n");

	}

	return 0;

}

/*

DWORD CALLBACK CtrlProc(LPVOID param)

{

	int i=0;

	while(1)

	{

		SetEvent(g_hevent);//发一个信号

		Sleep(1000);

		i++;

		if(i==1000) break;

	}

	return 0;

}

*/

void Thread()

{

	DWORD tid=0;

	char *txt="**************************";

	HANDLE hthread1=CreateThread(NULL,0,PrintProc,txt,

		0,&tid);

	/*

	//char *txt2="—————————————";

	//HANDLE hthread2=CreateThread(NULL,0,CtrlProc,txt2,

	//	0,&tid);

	//HANDLE ht[2]={0};

	//ht[0]=hthread1;

	//ht[1]=hthread2;

	//WaitForMultipleObjects(2,ht,TRUE,INFINITE);

	*/

	SetEnvironmentVariable("exit","0");

	while(1)

	{

		char c=getchar();

		if(c=='\0'||c=='\n') continue;

		int count=c-'0';

		printf("count1=%d  \n",count);

		if(count>=0&& count<=9)

		{

			printf("count2=%d  \n",count);

			ReleaseSemaphore(g_hSem,count,NULL);//又一次设置成5次

		}

		else if(c=='e'|| c=='E')

		{

			SetEnvironmentVariable("exit","1");

			ReleaseSemaphore(g_hSem,1,NULL);//又一次设置成5次

			break;

		}

	}

	WaitForSingleObject(hthread1,INFINITE);

	printf("wait over!\n");

	CloseHandle(hthread1);

	//CloseHandle(hthread2);

}

int main(int argc, char* argv[])

{

	g_hSem=CreateSemaphore(NULL,3,10,"s1");

	Thread();

	CloseHandle(g_hSem);

	return 0;

}