unix系统编程2

时间：2022-09-08 14:47:53

第二章 进程的生成(1)
    先说说什么是进程？假设你编好了一个程序，在它没有被调用之前，它只是乖乖地躺在你的硬盘上，什么事情都不干。好不容易编出来的不干活，这是我们不能容忍的。所以我们要把它调到内存里，然后通过CPU去执行它。所以说，进程就是一个在执行状态下的程序。
我们可以通过

  1. $ps –e
复制代码


命令来查看一下，计算机里所运行的进程有哪些。
那我们计算机里这么多的进程的又是从哪里来的呢，我们可以通过

  1. $ps –axwf
复制代码


来看到关于进程的一张家谱。其实，系统中的所有进程都是通过另一个进程生成的（除了0号进程以外），如果，A进程生成了B进程，那么可以把A进程叫做父进程，把B进程叫做A进程的子进程。也就是说，UNIX系统所有的进程都与其它进程保持着父子关系。

下面我们来看一个简单的例子

  1. #include<stdio.h>
  2. #include<sys/types.h>
  3. #include<unistd.h>
  4. int main( int argc , char *argv[])
  5. {
  6.         int time;
  7.         time = atoi( argv[1] )*60 ;       //将参数中的分钟换成秒数
  8.         if( fork()==0 )       //生成子进程，括号里是子进程的代码
  9.         {
  10.                 sleep( time );
  11.                 fprintf( stderr , "it is time to alarm!/n");
  12.         }
  13.         return 0;
  14. }
复制代码


执行时输入

  1. $./a.out 2
复制代码


这是一个简单的闹钟程序。你把它执行后，看似系统没有什么反映，其实不是，在后台你已经生成了一个进程，来监视时间。如果你用ps命令查看就能看到它。这时你可以接着干你自己的事情。等到了你设定的时间之后这个进程会提示你时间已经到了。这个程序虽不完善（没有进行输入参数的检查），但可以简单的告诉大家如何生成一个进程。
    为了生成一个新的进程，这里使用了 fork() 这个系统调用。它的作用是将父进程的各个变量的值复制给子进程，也就是说当你调用了fork()的那一刻，系统就为你生成了一个和父进程完全一样的进程。当然我们不想要一个父亲一样的孩子，孩子要有自己的个性，那我们如何来赋予孩子自己的个性呢？让我们先来看看fork()这个系统调用的概要。

  1. 头文件       #include <sys/types.h>
  2.                     #include <unistd.h>
  3. 形式       pid_t fork(void);
  4. 返回值          成功时：        父进程中：子进程的进程号（>0）
  5.                                 子进程中：=0
  6.                    失败时：        -1
复制代码

                        
根据上面fork()的特性，我们可以通过fork()的返回值区分父进程要做的事和子进程要做的事。例如，

  1. pid_t pid ;
  2. pid=fork();
  3. if( !pid)
  4. {
  5.         //子进程要做的事
  6. }else if(pid >0)
  7. {
  8.        //子进程生成失败时，父进程要做的事
  9. }else         //pid<0
  10. {
  11.         //子进程生成失败时，父进程要做的事
  12. }
复制代码



好，我们现在已经学会了生成一个子进程了。但它还是遗传了许多父进程的特性，有可能大家会想，能不能用我们生成的子进程来执行另一个与父进程没有任何关系的程序呢。当然是可以的，比如我们常说的shell就是就是这个样子。shell本身也是一个进程当你输入命令回车以后，shell会生成一个子进程来执行你的命令，这条命令可以和shell没有丝毫关系。为了更好的说明问题我们先来做一个简单的shell。当然是最简单的那种。
       

  1. #include<stdio.h>
  2. #include<sys/types.h>
  3. #include<unistd.h>
  4. int main()
  5. {
  6.         static      char prompt[64]="> ";
  7.         char    command[256];
  8.         int   st;
  9.         fprintf(stderr,"%s",prompt);    //  屏幕上的输出提示符
  10.         while(gets(command)!=NULL)  //  取得键盘输入
  11.         {
  12.                 if(fork()==0)     //  生成子进程
  13.                 {         //  子进程要做的事
  14.                        execl(command,command,(char *)0)==-1        //执行所输入的命令
  15.                 }
  16.                 else
  17.                 {         //  父进程要做的事
  18.                         wait(&st);  //  等待子进程结束
  19.                         fprintf(stderr,"%s",prompt);  //  输出提示符，等待命令
  20.                  }
  21.         }
  22.         return 0;
  23. }
复制代码


好了我们保存，编译，执行以下看看

  1. $./a.out
  2. >/bin/ls  //这里必须输入命令的完全路径
  3.         当前目录下文件名
  4. >Ctrl+D 退出程序
  5. $
复制代码


这样我们的一个最初级shell就做好了。虽然它还很弱，还有着安全上的漏洞（使用了gets()），甚至连自己退出都不能，但起码可以让我们看到一个shell是如何执行的了。其实，一个复杂的shell最基本的东西也就使这些。大家要是有兴趣的话可以将gets()换掉，再加上退出功能。

我们再说说程序中出现的一个新的函数execl()。其实它是exec函数组中的一个。这组函数有：

  1. int   execl( path , arg0 , arg1 , ... , argn , (char *)0 );
  2. int   execv( path , argv );
  3. int   execle( path , arg0 , arg1 , ... , argn , (char *)0 , envp );
  4. int   execve( path , argv , envp );
  5. int   execlp( file , arg0 , arg1 , ... , argn , (char *)0 );
  6. int   execvp( file , argv );
复制代码
  1. 参数定义如下：
  2. char *path;
  3. char *file;
  4. char *arg0 , *arg1 , ... , *argn;
  5. char *argv[];
  6. char *envp[];
  7. 返回值：        成功时：所执行的命令将会覆盖现有的进程，所以无返回值
  8.                         失败时：-1
复制代码


比如说我们在shell里执行

  1. $ /bin/ls –l
复制代码


这个命令，实际上shell调用的是

  1. execl( "/bin/ls" , "/bin/ls" , "-l"  , (char *)0 );
复制代码


的一个系统调用
这个函数组函数有6个，用法就不一一说明了，大家可以参看一下其它资料。这里只告诉大家它们的用处，exec函数组就是用来调用一个可执行程序。还有一点很重要，一但进程调用了exec函数那么写在exec函数后面的进程代码将会被覆盖，变成无效的代码了。
例如下面一段代码，我们想在execl执行后输出一段文字列，这是办不到的。

  1. if(fork()==0)     //  生成子进程
  2.                 {         //  子进程要做的事
  3.                        execl(command,command,(char *)0)==-1        //执行所输入的命令
  4.         fprinf(stderr,"lalalalalalalalala!");  //
  5.                 }
  6.                 else
  7.                 {         //  父进程要做的事
  8.                         wait(&st);  //  等待子进程结束
  9.                         fprintf(stderr,"%s",prompt);  //  输出提示符，等待命令
  10.                  }
复制代码


还有一个函数wait()，它的概要是

  1. #include <sys/types.h>
  2. pid_t wait(int *status);
复制代码


返回值就是子进程的进程号
它的参数是个指针。C语言里讲过，一个函数想有一个以上的返回值时，你可以将想返回的变量的地址作为函数的参数。比如说将数组地址作为函数的参数等等。其实这里的status就是这个道理，它的值与子进程的结束方式有关系。当你的子进程以exit()方式结束的话，status所指向的地址的前8位将会是exit()的参数的后8位，而status所指向的地址的后8位是0。例如子进程是exit(1);那status所指向的地址的内容应该是0000 0001 0000 0000。还有如果子进程是通过信号(signal)终止的(信号我们以后再讲),那么我们也可以通过status的值来判断是哪一个信号终止了这个子进程。（详见man）
我们为什么还要在父进程中调用wait()，这涉及到进程状态的概念，我们稍候再说。

标签：

相关文章