esalle
20135231 —— 第十一周任务总结报告

预计学习时间：7h

实际花费时间：9h

 

学习目标

　　·掌握进程控制
　　·掌握信号处理的方法
　　·掌握管道和fifo进行进程间通信的方法


学习任务

　　编译、运行、阅读、理解process.tar.gz压缩包中的代码

process代码

exec1

#include <stdio.h>
#include <unistd.h>

int main()
{
　　char *arglist[3];

　　arglist[0] = "ls";
　　arglist[1] = "-l";
　　arglist[2] = 0 ;//NULL
　　printf("* * * About to exec ls -l\n");
　　execvp( "ls" , arglist );
　　printf("* * * ls is done. bye");

　　return 0;
}

程序代码和运行结果如下：

　　这个代码中用了execvp函数，可以看到源代码中第二个printf语句消失了，是因为调用execvp函数时，内核将新程序载入到当前进程，替代当前进程的代码和数据。

　　execvp()搜索的PATH环境变量中指定的目录中的ls命令的位置，而传递参数的ls命令在argv中。 

　　因为在调用execvp函数时，内核将新程序载入到当前进程替代当前进程的代码和数据。

 

exec2

#include <stdio.h>
#include <unistd.h>

int main()
{
　　char *arglist[3];

　　arglist[0] = "ls";
　　arglist[1] = "-l";
　　arglist[2] = 0 ;
　　printf("* * * About to exec ls -l\n");
　　execvp( arglist[0] , arglist );
　　printf("* * * ls is done. bye\n");
}

exec2与exec1的区别就在于，execvp函数调用的语句变成了

execvp( arglist[0] , arglist );

编译运行结果与exec1.c完全相同，说明arglist数组的第一项为要运行的程序的名称。

 

 exec3

 

#include <stdio.h>

#include <unistd.h>

int main()

{

char *arglist[3]; 

char*myenv[3];

myenv[0] = "PATH=:/bin:";

myenv[1] = NULL;

arglist[0] = "ls";

arglist[1] = "-l"; 

arglist[2] = 0 ;

printf("* * * About to exec ls -l\n");

execlp("ls", "ls", "-l", NULL);

printf("* * * ls is done. bye\n");

}

 

　　

　　execlp()函数属于exec()函数族（exec()族函数用一个新的进程映像替换当前进程映像）它是execve(2)函数的前端。

　　execlp（从PATH 环境变量中查找文件并执行）。execlp()会从PATH 环境变量所指的目录中查找符合参数file的文件名，找到后便执行该文件，然后将第二个以后的参数当做该文件的argv[0]、argv[1]……，最后一个参数必须用空指针(NULL)作结束。

　　如果用常数0来表示一个空指针，则必须将它强制转换为一个字符指针，否则将它解释为整形参数，如果一个整形数的长度与char * 的长度不同，那么exec函数的实际参数就将出错。

　　如果函数调用成功,进程自己的执行代码就会变成加载程序的代码,execlp()后边的代码也就不会执行了，所以最后一句并未出现。

 

 forkdemo1

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
　　int ret_from_fork, mypid;
　　mypid = getpid();
　　printf("Before: my pid is %d\n", mypid);
　　ret_from_fork = fork();
　　sleep(1);
　　printf("After: my pid is %d, fork() said %d\n",
　　getpid(), ret_from_fork);

　　return 0;
}

　　这个代码先是打印进程pid，然后调用fork函数生成子进程，休眠一秒后再次打印进程id，这时父进程打印子进程pid，子进程返回0。

调用fork函数之后内核的工作过程：

　　分配新的内存块和内核数据结构

　　复制原来的进程到新的进程

　　向运行进程集添加新的进程

　　将控制返回给两个进程

 

 forkdemo2

#include <stdio.h>
#include <unistd.h>

int main()

{

printf("before:my pid is %d\n", getpid() );
fork();
fork();
printf("aftre:my pid is %d\n", getpid() );

return 0;

}

 

 这个代码调用两次fork，一共产生四个子进程，所以会打印四个aftre输出。

 

forkdemo3

 

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{

int fork_rv;

printf("Before: my pid is %d\n", getpid());

fork_rv = fork(); /* create new process */

if ( fork_rv == -1 ) /* check for error */
　　perror("fork");
else if ( fork_rv == 0 )

{
　　printf("I am the child. my pid=%d\n", getpid());
　　exit(0);
}
else

{
　　printf("I am the parent. my child is %d\n", fork_rv);
　　exit(0);
}

 return 0;

}

 

 

 fork产生子进程，父进程返回子进程pid，不为0，所以输出父进程的那句话，子进程返回0，所以会输出如上内容。

 

forkdemo4

 

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
　　int fork_rv; 

　　printf("Before: my pid is %d\n", getpid());

　　fork_rv = fork(); /* create new process */

　　if ( fork_rv == -1 ) /* check for error */
　　　　perror("fork");

　　else if ( fork_rv == 0 ){
　　　　printf("I am the child. my pid=%d\n", getpid());
　　　　printf("parent pid= %d, my pid=%d\n", getppid(), getpid());
　　　　exit(0);
　　}

　　else{
　　　　printf("I am the parent. my child is %d\n", fork_rv);
　　　　sleep(10);
　　　　exit(0);
　　}

　　return 0;
}

 

　　先打印进程pid，然后fork创建子进程，父进程返回子进程pid，所以输出parent一句，休眠十秒；子进程返回0，所以输出child与之后一句。

 

forkgdb

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int gi=0;
int main()
{

int li=0;
static int si=0;
int i=0;

pid_t pid = fork();
if(pid == -1){
　　exit(-1);
}
else if(pid == 0){
　　for(i=0; i<5; i++){
　　　　printf("child li:%d\n", li++);
　　　　sleep(1);
　　　　printf("child gi:%d\n", gi++);
　　　　printf("child si:%d\n", si++);
　　　}
　　exit(0);
}
else{
　　for(i=0; i<5; i++){
　　　　printf("parent li:%d\n", li++);
　　　　printf("parent gi:%d\n", gi++);
　　　　sleep(1);
　　　　printf("parent si:%d\n", si++);
　　}
　　exit(0);

}
return 0;

}

　　父进程打印是先打印两句，然后休眠一秒，然后打印一句，子进程先打印一句，然后休眠一秒，然后打印两句。并且这两个线程是并发的，所以可以看到在一个线程休眠的那一秒，另一个线程在执行，并且线程之间相互独立互不干扰。

 

 

psh1 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define MAXARGS 20
#define ARGLEN 100

int execute( char *arglist[] )
{

　　execvp(arglist[0], arglist);
　　perror("execvp failed");
　　exit(1);
}

char * makestring( char *buf )
{
　　char *cp;

　　buf[strlen(buf)-1] = '\0';
　　cp = malloc( strlen(buf)+1 );
　　if ( cp == NULL ){
　　　　fprintf(stderr,"no memory\n");
　　　　exit(1);
　　}
　　strcpy(cp, buf);
　　return cp;
}

int main()
{
　　char *arglist[MAXARGS+1];
　　int numargs;
　　char argbuf[ARGLEN];

　　numargs = 0;
　　while ( numargs < MAXARGS )
　　{
　　　　printf("Arg[%d]? ", numargs);
　　　　if ( fgets(argbuf, ARGLEN, stdin) && *argbuf != '\n' )
　　　　　　arglist[numargs++] = makestring(argbuf);
　　　　else
　　　　{
　　　　　　if ( numargs > 0 ){
　　　　　　　　arglist[numargs]=NULL;
　　　　　　　　execute( arglist );
　　　　　　　　numargs = 0;
　　　　　　}
　　　　}
　　}
　　return 0;

}

　　这个代码就相当于你输入要执行的指令，回车表示输入结束，然后输入的每个参数对应到函数中，再调用对应的指令。

 

psh2

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <signal.h>

#define MAXARGS 20
#define ARGLEN 100

char *makestring( char *buf )
{
　　char *cp;

　　buf[strlen(buf)-1] = '\0';
　　cp = malloc( strlen(buf)+1 );
　　if ( cp == NULL ){
　　　　fprintf(stderr,"no memory\n");
　　　　exit(1);
　　}
　　strcpy(cp, buf);
　　return cp;
} 

void execute( char *arglist[] )
{
　　int pid,exitstatus;

　　pid = fork();
　　switch( pid ){
　　　　case -1:
　　　　perror("fork failed");
　　　　exit(1);
　　　　case 0:
　　　　execvp(arglist[0], arglist);
　　　　perror("execvp failed");
　　　　exit(1);
　　　　default:
　　　　while( wait(&exitstatus) != pid )
　　　　;
　　　　printf("child exited with status %d,%d\n",
　　　　exitstatus>>8, exitstatus&0377);
　　}
}

int main()
{
　　char *arglist[MAXARGS+1];
　　int numargs;
　　char argbuf[ARGLEN];

　　numargs = 0;
　　while ( numargs < MAXARGS )
　　{
　　　　printf("Arg[%d]? ", numargs);
　　　　if ( fgets(argbuf, ARGLEN, stdin) && *argbuf != '\n' )
　　　　　　arglist[numargs++] = makestring(argbuf);
　　　　else
　　　　{
　　　　　　if ( numargs > 0 ){
　　　　　　　　arglist[numargs]=NULL;
　　　　　　　　execute( arglist );
　　　　　　　　numargs = 0;
　　　　　　}
　　　　}
　　}
　　return 0;
}

　　比起1来，多了循环判断，不退出的话就会一直要你输入指令，并且对于子程序存在的状态条件。

 

testbuf1

#include <stdio.h>
#include <stdlib.h>
int main()
{
　　printf("hello");
　　fflush(stdout);
　　while(1);
}

 

　　程序输出hello，无法退出。

 

testbuf2

#include <stdio.h>

int main()

{

　　printf("hello\n");

　　while(1);

}

 　　效果同1

 

testbuf3

#include <stdio.h>

int main()
{
　　fprintf(stdout, "1234", 5);
　　fprintf(stderr, "abcd", 4);
}

 　　将内容格式化输出到标准错误、输出流中。

 

 testpid

#include <stdio.h>
#include <unistd.h>

#include <sys/types.h>

int main()
{
　　printf("my pid: %d \n", getpid());
　　printf("my parent's pid: %d \n", getppid());
　　return 0;
}

　　 输出当前进程pid和当前进程的父进程的pid。

 

testpp

#include <stdio.h>

#include <stdlib.h> int main()

{

　　char **pp;

　　pp[0] = malloc(20);

　　return 0;

}

 

 

testsystem

#include <stdlib.h>

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

{

　　system(argv[1]);

　　system(argv[2]);

　　return EXIT_SUCCESS;

} 　　　　　　　　/* ---------- end of function main ---------- */

 

 

waitdemo1

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

#define DELAY 4

void child_code(int delay)
{
　　printf("child %d here. will sleep for %d seconds\n", getpid(), delay);
　　sleep(delay);
　　printf("child done. about to exit\n");
　　exit(17);
}

void parent_code(int childpid)
{
　　int wait_rv=0; /* return value from wait() */
　　wait_rv = wait(NULL);
　　printf("done waiting for %d. Wait returned: %d\n",
　　childpid, wait_rv);
}
int main()
{
　　int newpid;
　　printf("before: mypid is %d\n", getpid());
　　if ( (newpid = fork()) == -1 )
　　　　perror("fork");
　　else if ( newpid == 0 )
　　　　child_code(DELAY);
　　else
　　　　parent_code(newpid);

　　return 0;
}

 　　如果有子进程，则终止子进程，成功返回子进程pid

 

waitdemo2

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

#define DELAY 10

void child_code(int delay)
{
　　printf("child %d here. will sleep for %d seconds\n", getpid(), delay);
　　sleep(delay);
　　printf("child done. about to exit\n");
　　exit(27);
}

void parent_code(int childpid)
{
　　int wait_rv;
　　int child_status;
　　int high_8, low_7, bit_7; 

　　wait_rv = wait(&child_status);
　　printf("done waiting for %d. Wait returned: %d\n", childpid, wait_rv);

　　high_8 = child_status >> 8; /* 1111 1111 0000 0000 */
　　low_7 = child_status & 0x7F; /* 0000 0000 0111 1111 */
　　bit_7 = child_status & 0x80; /* 0000 0000 1000 0000 */
　　printf("status: exit=%d, sig=%d, core=%d\n", high_8, low_7, bit_7);
}

int main()
{
　　int newpid;

　　printf("before: mypid is %d\n", getpid());

　　if ( (newpid = fork()) == -1 )
　　　　perror("fork");
　　else if ( newpid == 0 )
　　　　child_code(DELAY);
　　else
　　　　parent_code(newpid);
}

　　如果有子进程，则终止子进程，成功返回子进程pid。并且多了一个子进程的状态区分，把状态拆分成exit，sig和core。

 

 

 

参考资料

process.tar.gz压缩包中的代码

课本《深入理解计算机系统》

闫佳歆博客：http://www.cnblogs.com/20135202yjx/p/5003653.html

百度

 

posted on 2015-11-29 19:32  20135231  阅读(136)  评论(0)  编辑  收藏  举报

Copyright © 2024 20135231
Powered by .NET 8.0 on Kubernetes Powered By博客园