进程控制

一.进程创建

1. fork函数初识(系统调用)

在linux中fork函数是非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。

#include <unistd.h>
pid_t fork(void);
返回值：自进程中返回0，父进程返回子进程id，出错返回-1

进程调用fork，当控制转移到内核中的fork代码后，内核做：

• 分配新的内存块和内核数据结构给子进程
• 将父进程部分数据结构内容拷贝至子进程
• 添加子进程到系统进程列表当中
• fork返回，开始调度器调度

当一个进程调用fork之后，就有两个二进制代码相同的进程。而且它们都运行到相同的地方。但每个进程都将可以开始它们自己的旅程，看如下程序。

这里看到了三行输出，一行before，两行after。进程43676先打印before消息，然后它有打印after。另一个after消息有43677打印的。注意到进程43677没有打印before，为什么呢？如下图所示

所以，fork之前父进程独立执行，fork之后，父子两个执行流分别执行。注意，fork之后，谁先执行完全由调度器决定。

2. fork函数返回值

• 子进程返回0，
• 父进程返回的是子进程的pid。

3. 写时拷贝

通常，父子代码共享，父子再不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本。具体见下图:

⼦进程修改数据的时候会把全部的数据写时拷⻉.修改的数据所在的⻚的整个数据,写时拷⻉的单位是⻚.这就是计算机的局部性原则，他认为你后⾯可能访问这个变量附近的空间，所以才会这样做的.

• 补充:进程地址空间=虚拟地址空间=进程虚拟地址空间=虚拟内存.

为什么要写时拷背?
1.减少创建时间
2.减少内存浪费

因为有写时拷贝技术的存在,所以父子进程得以彻底分离！完成了进程独立性的技术保证! 写时拷贝,是一种延时申请技术,可以提高整机内存的使用率.

4. fork常规用法

• 一个父进程希望复制自己，使父子进程同时执行不同的代码段。例如，父进程等待客户端请求，生成子进程来处理请求。

• 一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数。

5. fork调用失败的原因

• 系统中有太多的进程
• 实际用户的进程数超过了限制

二.进程终止

进程终止的本质是释放系统资源，就是释放进程申请的相关内核数据结构和对应的数据和代码。

1. 进程退出场景

• 代码运行完毕，结果正确–>return 0;
• 代码运行完毕，结果不正确–>return !0; {1,2,3}不同的值,表明不同的出错原因!
• 代码异常终止–>保存异常时对应的信号编号;退出码⽆意义!进程⼀旦出现异常,⼀般是进程收到了信号.

2. 进程常见退出方法

正常终止（可以通过echo $? [打印最近⼀个程序(进程)退出时的退出码]查看进程退出码）：

1. 从main返回,mian函数的返回值叫做进程退出码,进程退出码写到对应的进程的task_struct内部的!
2. 调用exit
3. _exit

异常退出：

• ctrl + c，信号终止

3.退出码

(1).退出码概念

退出码（退出状态）可以告诉我们最后一次执行的命令的状态。在命令结束以后，我们可以知道命令是成功完成的还是以错误结束的。其基本思想是，程序返回退出代码 0 时表示执行成功，没有问题。代码 1 或 0 以外的任何代码都被视为不成功。

Linux Shell 中的主要退出码：

退出码 0 表示命令执行无误，这是完成命令的理想状态。

• 退出码 1 我们也可以将其解释为 “不被允许的操作”。例如在没有 sudo 权限的情况下使用yum；再例如除以 0 等操作也会返回错误码 1 ，对应的命令为let a=1/0
• 130 （ SIGINT 或 ^C ）和 143 （ SIGTERM ）等终止信号是非常典型的，它们属于128+n 信号，其中 n 代表终止码。
• 可以使用strerror函数来获取退出码对应的描述。

(2)._exit函数(系统调用)

#include <unistd.h>
void _exit(int status);
参数：status 定义了进程的终止状态，父进程通过wait来获取该值

• 说明：虽然status是int，但是仅有低8位可以被父进程所用。所以_exit(-1)时，在终端执行$?发现返回值是255。

(3).exit函数(库函数)

#include <unistd.h>
void exit(int status);

exit最后也会调用_exit, 但在调用_exit之前，还做了其他工作：

1. 执行用户通过 atexit或on_exit定义的清理函数。

2. 关闭所有打开的流，所有的缓存数据均被写入

3. 调用_exit

• 任何地方调用exit,表示进程结束(函数不返回)!并返回给父进程,字进程的退出码.

• exit© vs _exit(系统)

1. exit()是库提供的;

   进程如果调⽤exit退出，exit()，进程退出的时候，会进行缓冲区的刷新.

2. _exit()是系统调⽤;
   进程如果调⽤_exit退出， _exit()，进程退出的时候，不会进行缓冲区的刷新.

我们之前谈论的缓冲区,应该在哪里,或者⼀定不在哪⾥?
答:⼀定不是操作系统内部的缓冲区! 是库缓冲区，C语言提供的缓冲区！

实例：

int main()
{
    printf("hello");
    exit(0);
}
运行结果:
[root@localhost linux]# ./a.out
hello[root@localhost linux]#

int main()
{
    printf("hello");
    _exit(0);
}
运行结果:
[root@localhost linux]# ./a.out
[root@localhost linux]#

(4).return退出

return是一种更常见的退出进程方法。执行return n等同于执行exit(n),因为调用main的运行时函数会将main的返回值当做 exit的参数。main函数结束，表示进程结束

三.进程等待

1. 进程等待必要性

• 之前讲过，子进程退出，父进程如果不管不顾，就可能造成‘僵尸进程’的问题，进而造成内存泄漏。
• 另外，进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的kill -9 也无能为力，因为谁也没有办法杀死一个已经死去的进程。
• 最后，父进程派给子进程的任务完成的如何，我们需要知道。如，子进程运行完成，结果对还是不对，或者是否正常退出。
• 父进程通过进程等待的方式，回收子进程资源(最重要)，获取子进程退出信息(可选的)

2. 进程等待的方法

(1).wait方法(系统调用)

等待任意一个退出的子进程!

如果等待子进程,子进程没有退出,父进程会阻塞在wait调用处(如scanf).

(2).waitpid方法(系统调用)

• 如果子进程已经退出，调用wait/waitpid时，wait/waitpid会立即返回，并且释放资源，获得子进程退出信息。
• 如果在任意时刻调用wait/waitpid，子进程存在且正常运行，则进程可能阻塞。
• 如果不存在该子进程，则立即出错返回。

(3).获取子进程status

• wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。
• 如果传递NULL，表示不关心子进程的退出状态信息。否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。
• status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特位）：

(4).阻塞与非阻塞等待

• 进程的阻塞等待方式：

• 进程的非阻塞等待方式：

四.进程程序替换

fork()之后,父子各自执行父进程代码的一部分如果子进程就想执行一个全新的程序呢？进程的程序替换来完成这个功能！

程序替换是通过特定的接口，加载磁盘上的一个全新的程序(代码和数据)，加载到调用进程的地址空间中！

1. 替换原理

用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。调用exec并不创建新进程，所以调用exec前后该进程的id并未改变。叫做进程的程序替换.

• 在程序替换的过程中，并没有创建新的进程，只是把当前进程的代码和数据用新的程序的代码和数据覆盖式的进行替换！

2. 替换函数

1. 一旦程序替换成功，就去执行新代码了，原始代码的后半部分，已经不存在了；
2. exec*函数，只有失败返回值，没有成功返回值;

总结:exec*系列的函数，不用做返回值判断，只要返回，就是失败！

其实有六种以exec开头的函数,统称exec函数:

除execve都是库函数

(1).函数解释

• 这些函数如果调用成功则加载新的程序从启动代码开始执行,不再返回。
• 如果调用出错则返回-1
• 所以exec函数只有出错的返回值而没有成功的返回值。

(2).命名理解

这些函数原型看起来很容易混,但只要掌握了规律就很好记。

• I(list):表示参数采用列表

• v(vector):参数用数组

• p(path):有p自动搜索环境变量PATH

• e(env):表示自己维护环境变量

  带e的都是覆盖式写，原始环境变量就没有了

exec调用举例如下:

事实上,只有execve是真正的系统调用,其它五个函数最终都调用execve,所以execve在man手册 第2节,其它函数在man手册第3节。这些函数之间的关系如下图所示。

下图exec函数簇一个完整的例子：

五.自主Shell命令行解释器

1. 目标

• 要能处理普通命令
• 要能处理内建命令
• 要能帮助我们理解内建命令/本地变量/环境变量这些概念
• 要能帮助我们理解shell的允许原理

2. 实现原理

考虑下面这个与shell典型的互动

用下图的时间轴来表示事件的发生次序。其中时间从左向右。bash由标识为bash的方块代表，它随着时间的流逝从左向右移动。shell从用户读入字符串"ls"。shell建立一个新的进程，然后在那个进程中运行ls程序并等待那个进程结束。

然后shell读取新的一行输入，建立一个新的进程，在这个进程中运行程序并等待这个进程结束。
所以要写一个shell，需要循环以下过程：

1. 获取命令行

2. 解析命令行

3. 建立一个子进程 (fork)

4. 替换子进程 (execvp)

5. 父进程等待子进程退出 (wait)

根据这些思路，和我们前面的学的技术，就可以自己来实现一个shell了。

3. 函数补充

C语言中
char*指向空间的内容都不是存在栈上面的；
char的内容全都是存在栈上面的.

• 缓冲区就是char[]的数组,存字符串用.

(1).gethostname(系统调用)

gethostname的作用是取当前机器的主机名,直接调用内核接口,不依赖环境变量。

函数原型

#include <unistd.h>

int gethostname(char *name, size_t len);

• 参数
  • name：存放主机名的缓冲区。
  • len：缓冲区大小(字节)。
• 返回值
  • 成功：返回 0。
  • 失败：返回 -1,并设置 errno。

---

(2).fgets(库函数)

fgets的作用是安全读取字符串,能限制读取长度,避免缓冲区溢出。

函数原型

#include <stdio.h>

char *fgets(char *str, int n, FILE *stream);

• 参数
  • str：目标缓冲区,用来存放读入的字符串。
  • n：最大读取字符数(包含最后的 \0),所以实际最多能读 n-1 个字符。
  • stream：输入流,一般用 stdin 表示键盘输入,也可以是文件指针。
• 返回值
  • 成功：返回 str。
  • 失败或到文件结束：返回 NULL。
• 停止条件
  • 读到换行符 \n。
  • 已经读取了 size - 1 个字符。
  • 读到 EOF(文件结束)。

---

(3).snprintf(库函数)

snprintf 的作用是把格式化后的字符串写入到一个缓冲区里,并且限制最多写入多少字符,防止内存越界。

函数原型

#include <stdio.h>

int snprintf(char *str, size_t size, const char *format, ...);

• 参数
  • str：目标缓冲区,用来存放格式化后的字符串。
  • size：缓冲区大小(字节),包含结尾的 \0。
  • format：格式化字符串,类似 printf。
  • …：可变参数,和 printf 用法一样。
• 返回值
  • 成功：返回欲写入的字符数(不包括结尾的 \0),即使实际因为缓冲区不够被截断。
  • 失败：返回负数(大多数库里是 -1)。

---

(4).fflush(库函数)

fflush 的作用是刷新缓冲区。

函数原型

#include <stdio.h>

int fflush(FILE *stream);

• 参数
  • stream：文件流指针,如:stdout、stdin、stderr、fopen打开的文件。
• 返回值
  • 成功返回 0；
  • 出错返回 EOF(EOF就是-1),并设置 errno。
• 例子:

printf("Hello");
fflush(stdout); // 确保 "Hello" 立刻显示,而不是等换行或程序结束

---

(5).strtok(库函数)

strtok的作用是分割字符串。

函数原型

#include <string.h>

char *strtok(char *str, const char *delim);

• 参数

  • str：要分割的字符串

    • 第一次调用时传入要分割的字符串(例如 "a,b,c")。
    • 后续调用要继续分割时,传入 NULL,表示接着上次的字符串继续分割。

  • delim：分隔符字符串,可以包含多个字符(例如 ",; ")。

• 返回值

  • 指向当前找到的子串的首地址(不返回空串,只返回有效串),如果没有更多子串,返回 NULL。

• 例1:一个分隔符

int main() {
    char str[] = "apple,banana,orange";
    char *token = strtok(str, ",");   // 第一次传入原始字符串
    while (token != NULL) 
    {
        printf("%s\n", token);
        token = strtok(NULL, ",");   // 之后传入 NULL,继续分割
    }
    return 0;
}
//输出：
apple
banana
orange

• 例2:多个分隔符

int main() {
    char str[] = "one, two;three four";
    char *token = strtok(str, " ,;");  // 分隔符是空格、逗号、分号
    while (token) 
    {
        printf("%s\n", token);
        token = strtok(NULL, " ,;");
    }
    return 0;
}
//输出：
one
two
three
four

注:strtok函数会修改原字符串,会把分隔符替换成 '\0',所以一定要传可修改的字符串(不能传字符串字面量)。

char str[] = "a,b,c";   // 可以
char *str = "a,b,c";    // 不行,会段错误

---

(6).chdir(系统调用)

chdir 的作用是改变进程当前工作目录。

函数原型

#include <unistd.h>

int chdir(const char *path);

• 参数
  • path：要切换到的目录路径,可以是绝对路径,也可以是相对路径 。
• 返回值
  • 成功：返回 0。
  • 失败：返回 -1,并设置全局变量 errno 。

注:只影响当前进程,chdir 改变的是当前进程的工作目录,对其他进程没有影响。

---

(7).getcwd(库函数)

getcwd的作用是获取当前工作目录

函数原型

#include <unistd.h>

char* getcwd(char *buf, size_t size);

• 参数
  • buf：存放结果的缓冲区。
  • size：缓冲区大小(字节)。
• 返回值
  • 成功：返回 buf 指针。
  • 失败：返回 NULL,并设置errno。

4. 源码

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <unistd.h>
#include <cstring>
#include <sys/types.h>
#include <sys/wait.h>
#include <unordered_map>

#define COMMAND_SIZE 1024
#define FORMAT "[%s@%s %s]# "

// 下面是shell定义的全局变量
// 1.命令行参数表
#define MAXARGC 128
char* g_argv[MAXARGC];
int g_argc = 0;

// 2.环境变量表
#define MAX_ENVS 100
char* g_env[MAX_ENVS];
int g_envs = 0;

// 3.别名映射表
std::unordered_map<std::string,std::string> g_alias; //提一下,不写了.

// for test
char cwd[1024];
char cwdenv[1024];

// last exit code
int lastcode=0;

const char* GetUserName()
{
   const char* name = getenv("USER");
   return name==NULL?"None":name;
}

const char* GetHostName()
{
   //const char* hostname = getenv("HOSTNAME");
   static char hostname[64];
   int i = gethostname(hostname,64);
   return i==-1?"None":hostname;
}

const char* GetPwd()
{
   //const char* pwd = getenv("PWD");
   const char* pwd = getcwd(cwd,sizeof(cwd));
   if(pwd != NULL)
   {
       // 法1:遍历g_env更新环境变量
       if (getenv("PWD") == NULL)
       {
           snprintf(cwdenv, sizeof(cwdenv), "PWD=%s", cwd);
           putenv(cwdenv);
           g_env[g_envs++] = cwdenv;
           g_env[g_envs] = NULL;
       }
       else
       {
           for (int i = 0; i < g_envs; i++)
           {
               if (strncmp(g_env[i], "PWD=", 4) == 0)
               {
                   snprintf(g_env[i], strlen(g_env[i]) + 1, "PWD=%s", cwd);
                   putenv(g_env[i]);
                   break;
               }
           }
       }

        //法2:用cwdenv临时变量
        // snprintf(cwdenv,sizeof(cwdenv),"PWD=%s",cwd);
        // putenv(cwdenv);
   }
   return pwd==NULL?"None":pwd;
}

const char* GetHome()
{
    const char* home = getenv("HOME");
    return home == NULL ? "" : home;
}

void InitEnv()
{
    extern char **environ;
    memset(g_env,0,sizeof(g_env));
    g_envs = 0;

    //本来要从配置文件来
    //1.获取环境变量
    for(int i = 0;environ[i];i++)
    {
        // 1.1申请空间
        g_env[i] = (char*)malloc(strlen(environ[i])+1);
        strcpy(g_env[i],environ[i]);
        g_envs++;
    }
    g_env[g_envs++] = (char*)"HAHA=for_test"; //测试标识
    g_env[g_envs] = NULL;

    //2.导成环境变量
    for(int i = 0; g_env[i];i++)
    {
        putenv(g_env[i]);
    }
    environ = g_env;
}


//command
bool Cd()
{
    if (g_argc == 1)
    {
        std::string home = GetHome();
        if (home.empty())
            return true;
        chdir(home.c_str());
    }
    else
    {
        std::string where = g_argv[1];
        // cd - / cd ~
        if (where == "-")
        {
            // Todu
        }
        else if (where == "~")
        {
            // Todu
        }
        else
        {
            chdir(where.c_str());
        }
    }
    return true;
}

void Echo()
{
    if (g_argc == 2)
    {
        // echo "hello world"
        // echo $?
        // echo $PATH
        std::string option = g_argv[1];
        if (option == "$?")
        {
            std::cout << lastcode << std::endl;
            lastcode = 0;
        }
        else if (option[0] == '$')
        {
            std::string env_name = option.substr(1);
            const char *env_value = getenv(env_name.c_str());
            if (env_value)
            {
                std::cout << env_value << std::endl;
            }
        }
        else
        {
            std::cout << option << std::endl;
        }
    }
}

//切割得到当前目录名
std::string DirName(const char* pwd)
{
#define SLASH "/" //注意:局部定义define外部也可以用
    std::string dir = pwd;
    if(dir==SLASH)return SLASH;
    auto pos = dir.rfind(SLASH);
    if(pos == std::string::npos)return "BUG?";
    return dir.substr(pos+1);
}

void MakeCommandLine(char cmd_prompt[],int size)
{
    snprintf(cmd_prompt,size,FORMAT,GetUserName(),GetHostName(),DirName(GetPwd()).c_str());
    //snprintf(cmd_prompt,size,FORMAT,GetUserName(),GetHostName(),GetPwd());
}

void PrintCommandPrompt()
{
    char prompt[COMMAND_SIZE];
    MakeCommandLine(prompt,sizeof(prompt));
    printf("%s",prompt);
    fflush(stdout);
}

bool GetCommandLine(char *out,int size)
{
    char *c = fgets(out,size,stdin);         
    if(c==NULL)return false;
    out[strlen(out)-1]=0;//清理\n
    if(strlen(out)==0)return false;
    return true;
}

bool CommandParse(char* commandline)
{
#define SEP " "
    //命令行分析"ls -a -l" -> "ls" "-a" "-l"
    g_argc = 0;
    g_argv[g_argc++] = strtok(commandline,SEP);

    while(g_argv[g_argc++] = strtok(nullptr,SEP));
    g_argc--;
    return g_argc > 0 ? true : false;
}

void PrintArgv()
{
    for(int i = 0; g_argv[i];i++)
    {
        printf("g_argv[%d]->%s\n",i,g_argv[i]);
    }
    printf("argc:%d\n",g_argc);
}

//检查是否是内键命令(有些内键命令磁盘上也有一份,是为了处理shell本身,shell脚本能用)
bool CheckAndExecBuiltin()
{
    std::string cmd = g_argv[0];
    if(cmd=="cd")
    {
        Cd();
        return true;
    }
    else if(cmd=="echo")
    {
        Echo();
        return true;
    }
    else if(cmd=="export")
    {
        //...
    }
    else if(cmd=="alias")
    {
        //...
    }
    return false;
}

int Execute()
{
    pid_t id = fork();
    if(id == 0)
    {
        //child
        execvp(g_argv[0],g_argv);
        exit(1);
    }
    int status = 0;
    //father
    pid_t rid = waitpid(id,&status,0);
    if(rid>0)
    {
        lastcode = WEXITSTATUS(status);
    }
    (void)rid; //用一下rid省的编译器告警
    return 0;
}

void clearup()
{
    for(int i = 0; i < g_envs; i++)
    {
        free(g_env[i]);
    }
}

int main()
{
    // shell启动的时侯,从系统中获取环境变量
    // 真实的shell从配置文件中读,但是配置文件是shell脚本,目前看不懂
    // 我们的环境变量信息直接从父shell统一来
    InitEnv();
    while(true)
    {
        //1.输出命令行提示符
        PrintCommandPrompt();

        //2.获取用户输入的命令
        char commandline[COMMAND_SIZE];
        if(!GetCommandLine(commandline,sizeof(commandline)))
            continue;

        //3.命令行分析"ls -a -l" -> "ls" "-a" "-l"
        if(!CommandParse(commandline))
            continue; 
        //PrintArgv();

        //可补:检查别名,替换命令

        //4.检查并处理内键命令
        if(CheckAndExecBuiltin())
            continue;

        //5.执行命令
        Execute();
    } 

    //释放堆空间
    clearup();
    return 0;
}

六.总结

在继续学习新知识前，我们来思考函数和进程之间的相似性

exec/exit就像call/return

一个C程序有很多函数组成。一个函数可以调用另外一个函数，同时传递给它一些参数。被调用的函数执行一定的操作，然后返回一个值。每个函数都有他的局部变量，不同的函数通过call/return系统进行通信。

这种通过参数和返回值在拥有私有数据的函数间通信的模式是结构化程序设计的基础。Linux鼓励将这种应用于程序之内的模式扩展到程序之间。如下图

一个C程序可以fork/exec另一个程序，并传给它一些参数。这个被调用的程序执行一定的操作，然后通过exit(n)来返回值。调用它的进程可以通过wait（&ret）来获取exit的返回值。