Linux基础第五章 进程控制

5.2 fork

fork函数实现进程复制，类似于动物界的单性繁殖，fork函数直接创建一个子进程。这是Linux创建进程最常用的方法。在这一小节中，子进程概念指fork产生的进程，父进程指主动调用fork的进程。

fork后，子进程继承了父进程很多属性，包括：

• 文件描述符：相当与dup，标准输入标准输出标准错误三个文件

• 账户/组ID：

• 进程组ID

• 会话ID

• 控制终端

• set-user-ID和set-group-ID标记

• 当前工作目录

• 根目录

• umask

• 信号掩码

• 文件描述符的close-on-exec标记

• 环境变量

• 共享内存

• 内存映射

• 资源限制

但是也有一些不同，包括：

• fork返回值

• 进程ID

• 父进程

• 进程运行时间记录，在子进程中被清0

• 文件锁没有继承

• 闹钟

• 信号集合

  #include <stdio.h>
  #include <unistd.h>
   #include <sys/types.h>
         #include <sys/stat.h>
         #include <fcntl.h>
  
  int main()
  {
      printf("before fork\n");
  
      // 在父进程中打开的文件描述符
  //    int fd = open("a.txt", O_RDWR|O_CREAT, 0777);
  
  //    FILE* fp = fopen("a.txt", "r");
      int fd = open("a.txt", O_RDWR);
      pid_t pid = fork(); // 创建一个新进程
      if(pid == 0)
      {
          // 子进程可以使用父进程的描述符
    //      write(fd, "hello", 5);
  
        //  char ch = fgetc(fp);
          char ch;
          read(fd, &ch, 1);
          printf("ch is %c\n", ch);
  
          printf("this is in child, ppid=%d\n", (int)getppid());
      }
      else if(pid > 0)
      {
      //    write(fd, "world", 5);
          char ch;
          read(fd, &ch, 1);
          printf("ch is %c\n", ch);
  
          // 当fork返回值大于0时，说明该进程是父进程
          // 此时，返回值就是子进程的pid
          printf("this is in parent, pid=%d\n", (int)getpid());
      }
      else
      {
          printf("error fork\n");
      }
  
      printf("hello fork\n");
  }

  #include <stdio.h>
  #include <unistd.h>
  
  int global_var = 0;//fork()出来的子进程的值改变，不会影响父进程  因为开开辟了新的空间
  
  int main()
  {
      int var = 0;
      int* p = (int*)malloc(sizeof(int));
      *p = 0;
  
      pid_t pid = fork();
      if(pid == 0)
      {
          global_var = 100;
          *p = 100;
          var = 100;
          printf("set var\n");
      }
      else if(pid > 0)
      {
          sleep(1);
          // 确定的结果，就是0
          printf("%d\n", global_var);
          printf("var is %d\n", var); // 0
          printf("*p = %d\n", *p);
      }
  
      printf("hello world\n");
  }

  #include <stdio.h>
  #include <unistd.h>
  
  void forkn(int n)
  {
      int i;
      for(i=0; i<n; ++i)
      {
          pid_t pid = fork();
          if(pid == 0)
              break;
      }
  }
  
  int main()
  {
      forkn(10);
  
      printf("hello world\n");
  }

5.3 进程终止

进程有许多终止方法：

方法
main函数return	正常退出
调用exit或者_Exit或者_exit	正常退出
在多线程程序中，最后一个线程例程结束	正常退出
在多线程程序中，最后一个线程调用pthread_exit	正常退出
调用abort	异常退出
收到信号退出	异常退出
多线程程序中，最后一个线程响应pthread_cancel	异常退出

当进程退出时，内核会为进程清除它申请的内存，这里的内存是指物理内存，比如栈空间、堆、代码段、数据段等，并且关闭所有文件描述符。

一般来说，进程退出时，需要告诉父亲进程退出的结果，如果是正常退出，那么这个结果保存在内核的PCB中。如果是异常退出，那么PCB中保存退出结果的字段，是一个不确定的值。因此程序员应该避免程序的异常退出。

进程退出时，除了它的PCB所占内存，其他资源都会清除。

5.4 wait和waitpid

一个进程终止后，其实这个进程的痕迹还没有完全被清除，因为还有一个PCB在内核中，如果不回收，那么会导致内存泄漏。父进程可以调用wait函数来回收子进程PCB，并得到子进程的结果。

wait是一个阻塞调用，它的条件是一个子进程退出或者一个子进程有状态变化。
wait得到的status，包含了子进程的状态变化原因和退出码信息等等。

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

int main()
{
    pid_t pid = fork();

    if(pid == 0)
    {
        sleep(1);
        printf("child process\n");

        return 18;
    }
    else if(pid > 0)
    {
        printf("parent process\n");

        // 等待子进程结束，并且回收子进程的PCB
        int status;
        wait(&status);

        // 如何得到子进程的返回值
        if(WIFEXITED(status))
        {
            printf("normal child process exit\n"); // 正常退出

            int code =WEXITSTATUS(status);
            printf("code is %d\n", code);
        }
        else if(WIFSIGNALED(status))
        {
            printf("signal\n");
        }
        else if(WIFSTOPPED(status))
        {
            printf("child stopped\n");
        }
        else if(WIFCONTINUED(status))
        {
            printf("child continue...\n");
        }

        printf("after wait\n");
    }

    return 0;
}

wait和waitpid可能会阻塞父进程，所以一般使用SIGCHLD信号来监控子进程

5.5 僵尸进程和孤儿进程

5.5.1 僵尸进程

是指已经退出的进程，但是父进程没有调用wait回收的子进程。僵尸进程没有任何作用，唯一的副作用就是内存泄漏。如果父进程退出，那么它的所有僵尸儿子会得到清理，因此僵尸进程一般指那些用不停歇的后台服务进程的僵尸儿子。

程序员应该避免僵尸进程的产生。

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

int main()
{
    pid_t pid = fork();
    if(pid == 0)
    {
        // 子进程什么事儿都不干，退出了，此时子进程是僵尸进程
    }
    else if(pid > 0)
    {
        getchar(); // 父进程不退出
    }

    return 0;
}

5.5.2 孤儿进程

父进程退出了，而子进程没有退出，那么子进程就成了没有父亲的孤儿进程。孤儿进程不会在系统中出现很长时间，因为系统一旦发现孤儿进程，就会将其父进程设置为init进程。那么将来该进程的回收，由init来负责。

5.6 exec

exec函数执行一个进程，当一个进程调用exec后，调用该函数的进程的虚拟地址空间的代码段、数据段、堆、栈被释放，替换成新进程的代码段、数据段、堆、栈，而PCB依旧使用之前进程的PCB。这个函数用中文来说就是鸠占鹊巢。

exec后使用的是同一个PCB，所以exec之后和之前，由很多进程属性是相同的，包括：

• 进程ID和父进程ID

• 账户相关

• 进程组相关

• 定时器

• 当前目录和根目录

• umask

• 文件锁

• 信号mask

• 未决的信号

• 资源限制

• 进程优先级

• 进程时间

• 没有close-on-exec属性的文件描述符

使用fork和exec来执行一个新程序

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

// execle, e表示环境变量environ
//
int main(int argc, char* argv[])
{
    char* args[] = {
        "/bin/ls",
        "-a",
        "-l",
        NULL
    };
    execv("/bin/ls", args);
}

int main2(int argc, char* argv[])
{
    // p表示在PATH的环境变量中寻找这个程序
    execlp("ls", "ls", NULL);
}

int main1(int argc, char* argv[])
{
    // 执行一个程序
    execl("/bin/ls", "/bin/ls", "-a", "-l", NULL);

    // 该函数不会被执行
    printf("hello world\n");
}

#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>

int main()
{
    // fd is 3
    int fd = open("exec.txt", O_RDWR|O_CREAT|O_CLOEXEC, 0777);

    execl("./exec_test", "./exec_test", NULL);
}

int execl(const char *path, const char *arg, ...);

int execlp(const char *file, const char *arg, ...);

int execle(const char *path, const char *arg,

                  ..., char * const envp[]);

int execv(const char *path, char *const argv[]);

int execvp(const char *file, char *const argv[]);

int execvpe(const char *file, char *const argv[],

                   char *const envp[]);

 

函数后缀	解析
l	list 用不定参数列表来表示命令参数，如果用不定参数列表，那么用NULL表示结束
v	vector 用数组来传递命令行参数
p	path 表示程序使用程序名即可，在$PATH中搜索该程序，不带p的需要提供全路径
e	environ 表示环境变量

补充：不定参数

不定参数函数定义：

#include "../h.h"

 

#define mylog(fmt, ...) myprint(__FILE__, __LINE__, fmt, __VA_ARGS__)

 

void myprint(const char* filename, int line, const char* fmt, ...)

{

    printf("%s, %d, ", filename, line);

    va_list ap;

    va_start(ap, fmt);

    vprintf(fmt, ap);

    va_end(ap);

}

 

int print(const char* a, ...)

{

    const char* arg = a;

    va_list args;

    va_start(args, a);

 

    while(arg)

    {

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

        arg = va_arg(args, const char*);

    }

#if 0

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

 

    while(1)

    {

        const char* arg = va_arg(args, const char*);

        if(arg == NULL)

            break;

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

    }

#endif

 

    va_end(args);

}

 

int add(int count, ...)

{

    int i;

    int sum = 0;

    va_list args;

    // 获得不定参数的首地址

    va_start(args, count);

 

    for(i=0; i<count; ++i)

    {

        // 通过va_arg获得参数

        int arg = va_arg(args, int);

        sum += arg;

    }

    // 参数获取完毕

    va_end(args);

 

    return sum;

}

 

int main()

{

    myprint(__FILE__, __LINE__, "haha%d\n", 100);

    mylog("print in mylog %d\n", 100);

    print("hello", "world", "haha", "you are dead", NULL);

    int ret = add(3, 5, 6, 7);

    printf("%d\n", ret);

    return 0;

}

int main()
{
    int a = add(3, 12, 13, 14);
    int b = add(2, 12, 13);
    int c = add(4, 12, 13, 14, 15);
     printf("%d, %d, %d\n", a, b, c);

    char* p = concat("abc", "bcd", NULL);
    printf("p is %s\n", p);

    // 最后的NULL，被称之为哨兵
    p = concat("aaaa", "bbbb", "cccc", NULL);
    printf("p is %s\n", p);

}

#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>

// 如果没有__VA_ARGS__不带##，表示__VA_ARGS__至少要表示一个参数
// #define mylog(fmt, ...) printf("[%s:%d] "fmt, __FILE__, __LINE__, __VA_ARGS__)

// __VA_ARGS__如果有##，表示可以没有参数
#define mylog(fmt, ...) printf("[%s:%d] "fmt, __FILE__, __LINE__, ##__VA_ARGS__)

int main()
{
    int fd = open("a.txt", O_RDWR);
    if(fd < 0)
    {
        mylog("error open file\n");
    }
}

#include <stdio.h>

// 转字符串 abc "abc"
#define STR(a) #a

// 拼接标识符
#define CC(a, b) a##b

int main()
{
    int abcxyz = 100;
    printf("%d\n", CC(abc, xyz));
}

5.8 账户和组控制

5.9 进程间关系

在Linux系统中，进程间除了有父子关系，还有组关系、Session关系、进程和终端进程关系。设计这些关系是为了更好的管理进程。

5.9.1 Session

一次登陆算一个session，exit命令可以退出session，session包括多个进程组，一旦session领导退出，那么一个session内所有进程退出（它的所有进程收到一个信号）。

#include <unistd.h>
int main()
{
    pid_t pid = fork();

    if(pid == 0)
    {
            // 独立一个session
            setsid();
    }

    while(1)
    {
        sleep(1);
    }
}

5.9.2 进程组

在终端执行进程，就会生成一个进程组。执行的进程fork之后，子进程和父进程在一个组中。

进程组长退出后，进程组的其他进程的组号依旧没有变化。

5.10 练习

5.10.1 fork任意个子进程。

int main()

{

    int i;

    for(i=0; i<7; ++i)

    {

        pid_t pid = fork();

        if(pid == 0)

            break;

    }

}

5.10.2 使用多进程加速文件拷贝

./mycp -job 4 srcfile destfile

使用-job定义进程数量，加速文件拷贝。

 

#include "../h.h"

 

int get_file_length(const char* filename)

{

    struct stat buf;

    int ret = stat(filename, &buf);

    if(ret == -1)

        return -1;

    return buf.st_size;

}

 

void process_copy(const char* src_file, const char* dst_file, int pos, int length)

{

    FILE* src = fopen(src_file, "r");

    FILE* dst = fopen(dst_file, "r+");

 

    char buf[4096];

    int block_size = sizeof(buf);

 

    fseek(src, pos, SEEK_SET);

    fseek(dst, pos, SEEK_SET);

 

    while(length)

    {

        int copy_len = length < block_size ? length : block_size;

        int ret = fread(buf, 1, copy_len, src);

        fwrite(buf, ret, 1, dst);

        length -= ret;

    }

 

    fclose(src);

    fclose(dst);

}

 

// ./multi-process-cp -job n srcfile dstfile

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

{

    if(argc != 5)

    {

        printf("usage %s -job {process_count} {src_file} {dst_file}\n", argv[0]);

        return 1;

    }

 

    if(strcmp(argv[1], "-job") != 0)

    {

        printf("unknown options: %s\n", argv[1]);

        return 2;

    }

 

    int process_count = atoi(argv[2]);

    if(process_count <= 0)

    {

        printf("process count error\n");

        return 3;

    }

 

    const char* src_file = argv[3];

    const char* dst_file = argv[4];

 

    // 获得文件总长度

    int filelen = get_file_length(src_file);

    if(filelen == -1)

    {

        printf("file not exist\n");

        return 3;

    }

 

    // 保证dst文件存在，并且dst的文件尺寸是src文件一样大

    int fd = open(dst_file, O_CREAT|O_WRONLY, 0777);

//    ftruncate(fd, filelen);

    close(fd);

    truncate(dst_file, filelen);

 

    // 4 process 21 字节 21/4 = 5

    // 0 0~4

    // 1 5-9

    // 2 10-14

    // 3 21-15 6

    int i;

    int average = filelen / process_count;

    // 只要创建n-1个子进程，父进程负责最后部分的拷贝

    for(i=0; i<process_count-1; ++i)

    {

        pid_t pid = fork();

        if(pid == 0)

        {

            // 子进程拷贝完成直接结束

            int pos = average * i;

            process_copy(src_file, dst_file, pos, average);

            return 0;

        }

    }

 

    int pos = average * i;

    process_copy(src_file, dst_file, pos, filelen - pos);

 

    // wait一次只wait一个子进程

    for(i=0; i<process_count-1; ++i)

        wait(NULL);

 

    return 0;

}

5.10.3 实现自定义终端

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

// ls
// mkdir aaa
// cp ../aa bb
// cd
void handle_cmd(char* cmd)
{
    char* args[1024];
    char* p = strtok(cmd, " ");
    int i = 0;
    while(p)
    {
        args[i++] = p;
        p = strtok(NULL, " ");
    }
    args[i] = NULL; // 表示参数结束位置

    if(strcmp(args[0], "cd") == 0)
    {
        // 切换当前目录
        chdir(args[1]);
        return;
    }

    pid_t pid = fork();
    if(pid == 0)
    {
        execvp(args[0], args);
        // 如果命令执行失败，应该让子进程退出
        printf("invalid command\n");
        exit(0);
    }
    else
    {
        wait(NULL);
    }
}

int main()
{
    while(1)
    {
        printf("myshell> ");
        // 等待用户输入
        char buf[4096];
        fgets(buf, sizeof(buf), stdin);
        buf[strlen(buf)-1] = 0; // remove \n

        if(strlen(buf) == 0)
        {
            continue;
        }

        handle_cmd(buf);
    }
}

5.11 函数和命令

5.11.1 函数

fork：创建子进程
exec：执行新的程序
wait/waitpid：等待子进程结束，回收子进程PCB内存。
va_list：
va_start：定义指向不定参数的第一个参数的地址
va_arg：从参数列表中获取一个参数，并且让指针指向下一个参数
va_end：清除ap