进程控制编程
进程控制理论基础
一、进程的定义
进程是一个具有一定独立功能的程序的一次运行活动,同时也是资源分配的最小单元;
二、进程与程序
程序——放到磁盘的可执行文件
进程——指程序执行的实例
区别:
·进程是动态的,程序使静态的:程序是有序代码的集合;进程是程序的执行。通常进程不
可在计算机之间迁移;而程序通常对应着文件、静态和可以复制
·进程是暂时的,程序使长久的:进程是一个状态变化的过程,程序可长久保存
·进程与程序组成不同:进程的组成包括程序、数据和进程控制块(即进程状态信息)
·进程与程序的对应关系:通过多次执行,一个程序可对应多个进程;通过调用关系,一个
进程可包括多个程序。
三、进程的生命周期
·创建: 每个进程都是由其父进程创建进程可以创建子进程,子进程又可以创建子进程的
子进程
·运行: 多个进程可以同时存在进程间可以通信
·撤销: 进程可以被撤销,从而结束一个进程的运行
四、进程的状态
·执行状态:进程正在占用CPU
·就绪状态:进程已具备一切条件,正在等待分配CPU的处理时间片
·等待状态:进程不能使用CPU,若等待事件发生则可将其唤醒
五、Linux进程
Linux系统是一个多进程的系统,它的进程之间具有并行性、互不干扰等特点。
也就是说,每个进程都是一个独立的运行单位,拥有各自的权利和责任。其中,各个进程都运行在独立的虚拟地址空间,因此,即使一个进程发生异常,它也不会影响到系统中的其他进程。
六、Linux下进程地址空间
·Linux中的进程包含3个段,分别为“数据段”、“代码段”和“堆栈段”。
·“数据段”存放的是全局变量、常数以及动态数据分配的数据空间;
·“代码段”存放的是程序代码的数据。
·“堆栈段”存放的是子程序的返回地址、子程序的参数以及程序的局部变量等。
七、进程ID
·进程ID(PID):标识进程的唯一数字
·父进程的ID(PPID)
·启动进程的用户ID(UID)
八、进程互斥
进程互斥是指当有若干进程都要使用某一共享资源时,任何时刻最多允许一个进程使用,其他要使用该资源的进程必须等待,直到占用该资源者释放了该资源为止
九、临界资源
操作系统中将一次只允许一个进程访问的资源称为临界资源
临界区
进程中访问临界资源的那段程序代码称为临界区,为实现对临界资源的互斥访问,应保证诸进程互斥地进入各自的临界区
十、进程同步
· 一组并发进程按一定的顺序执行的过程称为进程间的同步
· 具有同步关系一组并发进程称为合作进程,
· 合作进程间互相发送的信号称为消息或事件
十一、进程调度
·概念:
按一定算法,从一组待运行的进程中选出一个来占有CPU运行。
·调度方式:
• 抢占式
• 非抢占式
十二、调度算法
·先来先服务调度算法
·短进程优先调度算法
·高优先级优先调度算法
·时间片轮转法
十三、死锁
多个进程因竞争资源而形成一种僵局若无外力作用,这些进程都将永远不能再向前推进
进程控制编程
获取ID ——getpid
函数的作用:获取进程识别码,进程号
函数的原型: pid_t getpid(void);
返 回 值:目前进程的进程号;
头文件: #include <unistd.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main(void)
{
printf( "PID = %d\n", getpid() );
printf( “PPID = %d\n”, getppid() );
return 0;
}
进程创建—— fork
函数的作用:创建一个进程
函数的原型:pid_t fork(void);
函数的返回值: <0 出错;
=0 表示当前创建的子进程
>0 父进程 ,返回值是子进程的进程号
性质:
fork创建的子进程把父进程的资源拷贝了一份, 父子进程把所有的重新执行一遍;
vfork创建的子进程和父进程共享数据空间, 不是重新拷贝
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <math.h>
/* 进程创建 */
void main(void)
{
pid_t child;
int status;
printf("This will demostrate how to get child status\n");
/* 创建子进程 */
if((child=fork())==-1)
{
printf("Fork Error : %s\n", strerror(errno));
exit(1);
}
else if(child==0) // 子进程
{
int i;
printf("I am the child: %s\n", getpid());
for(i=0;i<1000000;i++) sin(i);
i=5;
printf("I exit with %d\n", i);
exit(i);
}
while(((child=wait(&status))==-1)&(errno==EINTR)); //子进程未结束
if(child==-1)
printf("Wait Error: %s\n", strerror(errno));
else if(!status) // 子进程退出值为0
printf("Child %ld terminated normally return status is zero\n", child);
else if(WIFEXITED(status)) // 子进程退出值0
printf("Child %ld terminated normally return status is %d\n", child, WEXITSTATUS(status));
else if(WIFSIGNALED(status)) // 子进程未获信号而退出
printf("Chlid %ld terminated due to signal %d not caught\n", child, WTERMSIG(status));
}
进程创建——vfork
函数的作用:建立一个新的进程;
函数的原型: pid_t vfork();
特点:子进程先运行,退出,父进程才能运行
#include<unistd.h>
main()
{
if(vfork() = =0)
{
printf(“This is the child process\n”);
}
else
{
printf(“This is the parent process\n”);
}
}
fork PK vfork
区别:
1. fork:子进程拷贝父进程的数据段
vfork:子进程与父进程共享数据段
2. fork:父、子进程的执行次序不确定
vfork:子进程先运行,父进程后运行
1.进程的创建: fork(), vfork();
2.进程的执行:exec函数族
执行进程——execl
函数的作用: 执行一个文件,
函数原型: int execl(const char *path, const char *arg,..)
参数说明: path:代表的文件路径;
arg: 表示argv[0], argv[1],...
最后一个以NULL结束;
返 回 值:成功函数没有返回,出错-1;
执行进程——execv
函数的作用: 执行一个文件,
函数原型:int exev(const char *path, char * const argv[])
函数的参数: path:代表的文件路径;
argv:是一个数组里的指针传递过来;
返 回 值: 成功不返还,出错-1
#include <unistd.h>
int main()
{
char * argv[ ]={“ls”,”-l”,
”/etc/passwd”,(char*)0};execv(“/bin/ls”,argv);
}
执行命令——system
函数的作用:执行一个命令
函数的原型: int system(const char * string);
进程等待——wait
函数的作用: 进程的等待,阻塞进程,等待某个子进程退出;
函数的原型: pid_t wait(int *status);
返回值:成功返回子进程PID,出错-1;
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
int main(void)
{
pid_t pid;
int status,i;
if(fork()==0)
{
printf(“This is the child process .pid =%d\n”,getpid());
exit(5);
}
else
{
sleep(1);
printf(“This is the parent process ,wait for child...\n”;
pid=wait();
//i=WEXITSTATUS(status);
printf(“child’s pid =%d .exit status=^d\n”,pid,i);
}
return 0;
}
进程等待——waitpid
函数的作用:等待退出,等待信号,或者指定的进程结束
函数的原型:pid_t waitpid(pid_t pid , int *status, int options);
函数的参数:
pid <-1 :等待进程的Pid绝对值的任何的子进程;
pid=-1, 任何子进程,---等于wait;
pid=0,
pid >0, 等待子进程为pid的子进程退出
options:
WNOHANG:如果没有子进程退出,马上返回不等待
WUNTRACED:如果子进程进入暂停执行情况,马上返回,
返 回 值:如果执行成功返回的是子进程的PID,失败-1;
如果使用WNOHANG的时候,没有子进程退出,
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
void die(const char *msg)
{
perror(msg);
exit(1);
}
void child2_do()
{
printf("In child2: execute 'date'\n");
sleep(5);
if (execlp("date", "date", NULL) < 0) {
perror("child2 execlp");
}
}
void child1_do(pid_t child2, char *argv)
{
pid_t pw;
do {
if (*argv == '1') {
pw = waitpid(child2, NULL, 0);
}
else {
pw = waitpid(child2, NULL, WNOHANG);
}
if (pw == 0) {
printf("In child1 process:\nThe child2 process has not exited!\n");
sleep(1);
}
}while (pw == 0);
if (pw == child2) {
printf("Get child2 %d.\n", pw);
sleep(5);
if (execlp("pwd", "pwd", NULL) < 0) {
perror("child1 execlp");
}
}
else {
printf("error occured!\n");
}
}
void father_do(pid_t child1, char *argv)
{
pid_t pw;
do {
if (*argv == '1') {
pw = waitpid(child1, NULL, 0);
}
else {
pw = waitpid(child1, NULL, WNOHANG);
}
if (pw == 0) {
printf("In father process:\nThe child1 process has not exited.\n");
sleep(1);
}
}while (pw == 0);
if (pw == child1) {
printf("Get child1 %d.\n", pw);
if (execlp("ls", "ls", "-l", NULL) < 0) {
perror("father execlp");
}
}
else {
printf("error occured!\n");
}
}
int main(int argc, char *argv[])
{
pid_t child1, child2;
if (argc < 3) {
printf("Usage: waitpid [0 1] [0 1]\n");
exit(1);
}
child1 = fork();
if (child1 < 0) {
die("child1 fork");
}
else if (child1 == 0) {
child2 = fork();
if (child2 < 0) {
die("child2 fork");
}
else if (child2 == 0) {
child2_do();
}
else {
child1_do(child2, argv[1]);
}
}
else {
father_do(child1, argv[2]);
}
return 0;
}
进程退出——exit
函数的作用:正常结束进程
函数原型: void exit(int status)