进程控制编程
进程控制理论基础
一、进程的定义
进程是一个具有一定独立功能的程序的一次运行活动，同时也是资源分配的最小单元；
二、进程与程序
程序——放到磁盘的可执行文件
进程——指程序执行的实例
区别：
·进程是动态的，程序使静态的：程序是有序代码的集合；进程是程序的执行。通常进程不
可在计算机之间迁移；而程序通常对应着文件、静态和可以复制
·进程是暂时的，程序使长久的：进程是一个状态变化的过程，程序可长久保存
·进程与程序组成不同：进程的组成包括程序、数据和进程控制块（即进程状态信息）
·进程与程序的对应关系：通过多次执行，一个程序可对应多个进程；通过调用关系，一个
进程可包括多个程序。
三、进程的生命周期
·创建: 每个进程都是由其父进程创建进程可以创建子进程，子进程又可以创建子进程的
子进程
·运行: 多个进程可以同时存在进程间可以通信
·撤销: 进程可以被撤销，从而结束一个进程的运行
四、进程的状态
·执行状态：进程正在占用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)
675
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
