你在终端启动的进程，最后都是什么下场？（下）

在上期文章你在终端启动的进程，最后都是什么下场？（上）当中我们介绍了前台进程最终结束的几种情况，在本篇文章当中主要给大家介绍后台进程号可能被杀死的几种情况。

揭秘nohup——后台进程的死亡

如果大家有过让程序在后台持续的运行，当你退出终端之后想让你的程序继续在后台运行，我们通常会使用命令 nohup。那么现在问题来了，为什么我们让程序在后台运行需要 nohup 命令，nohup 命令又做了什么？

在前面的文章你在终端启动的进程，最后都是什么下场？（上）当中我们已经谈到了，当你退出终端之后 shell 会发送 SIGHUP 信号给前台进程组的所有进程，然后这些进程在收到这个信号之后如果没有重写 SIGHUP 信号的 handler 或者也没有忽略这个信号，那么就会执行这个信号的默认行为，也就是退出程序的执行。

事实上当你退出终端之后 shell 不仅给前台进程组的所有进程发送 SIGHUP 信号，而且也会给所有的后台进程组发送 SIGHUP 信号，因此当你退出终端之后你启动的所有后台进程都会收到一个 SIGHUP 信号，注意 shell 是给所有的后台进程组发送的信号，因此如果你的后台进程是一个多进程的程序的话，那么你这个多进程程序的每一个进程都会收到这个信号。

根据上面的分析我们就可以知道了当我们退出终端之后，shell 会给后台进程发送一个 SIGHUP 信号。在我们了解了 shell 的行为之后我们应该可以理解为什么我么需要 nohup 命令，因为我们正常的程序是没有处理这个 SIGHUP 信号的，因此当我们退出终端之后所有的后台进程都会收到这个信号，然后终止执行。

看到这里你应该能够理解 nohup 命令的原理和作用了，这个命令的作用就是让程序忽略 SIGHUP 这个信号，我们可以通过 nohup 的源代码看出这一点。

nohup 的核心代码如下所示：

int
main(int argc, char *argv[])
{
	int exit_status;

	while (getopt(argc, argv, "") != -1)
		usage();
	argc -= optind;
	argv += optind;
	if (argc < 1)
		usage();

	if (isatty(STDOUT_FILENO))
		dofile();
	if (isatty(STDERR_FILENO) && dup2(STDOUT_FILENO, STDERR_FILENO) == -1)
		/* may have just closed stderr */
		err(EXIT_MISC, "%s", argv[0]);

	(void)signal(SIGHUP, SIG_IGN); // 在这里忽略 SIGHUP 这个信号

	execvp(*argv, argv); // 执行我们在命令行当中指定的程序
	exit_status = (errno == ENOENT) ? EXIT_NOTFOUND : EXIT_NOEXEC;
	err(exit_status, "%s", argv[0]);
}

在上面的程序当中我们可以看到，在 main 函数当中，nohup 首先创建使用 signal 忽略了 SIGHUP 信号，SIG_IGN 就是忽略这个信号，然后使用 execvp 执行我们在命令行当中指定的程序。

这里需要注意一点的是关于 execvp 函数，也就是 execve 这一类系统调用，只有当我们使用 SIG_IGN 忽略信号的时候，才会在 execvp 系列函数当中起作用，如果是我们自己定义的信号处理器 (handler)，那么在我们执行完 execvp 这个系统调用之后，所有的我们自己定义的信号处理器的行为都将失效，所有被重新用新的函数定义的信号都会恢复成信号的默认行为。

比如说下面这个程序：

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

void sig(int no)
{
  char* s = "Hello World\n";
  write(STDOUT_FILENO, s, strlen(s));
  sync();
}

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

  signal(SIGINT, sig);
  execvp(argv[1], argv);
}

在上面的程序当中我们定义了一个信号处理器 sig 函数，如果接受到 SIGINT 信号那么就会执行 sig 函数，但是我们前面说了，因为只有 SIG_IGN 才能在 execvp 函数执行之后保持，如果是自定函数的话，那么这个信号的行为就会被重置成默认行为，SIGINT 的默认行为是退出程序，现在我们使用上面的程序去加载执行一个死循环的程序，执行结果如下：

从上面的程序的输出结果我们就可以知道，在我们按下 ctrl + c 之后进程会收到一个来自内核的 SIGINT 信号，但是并没有执行我们设置的函数 sig ，因此验证了我们在上文当中谈到的结论！

有心的同学可能会发现当我们在终端使用 nohup 命令的时候会生成一个 "nohup.out" 文件，记录我们的程序的输出内容，我们可以在 nohup 的源代码当中发现一点蛛丝马迹，我们可以看一下 nohup 命令的完整源代码：

#if 0
#ifndef lint
static const char copyright[] =
"@(#) Copyright (c) 1989, 1993\n\
	The Regents of the University of California.  All rights reserved.\n";
#endif /* not lint */

#ifndef lint
static char sccsid[] = "@(#)nohup.c	8.1 (Berkeley) 6/6/93";
#endif /* not lint */
#endif
#include <sys/cdefs.h>
__FBSDID("FreeBSD");

#include <sys/param.h>
#include <sys/stat.h>

#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

static void dofile(void);
static void usage(void);

#define	FILENAME	"nohup.out" // 定义输出文件的文件名
/*
 * POSIX mandates that we exit with:
 * 126 - If the utility was found, but failed to execute.
 * 127 - If any other error occurred. 
 */
#define	EXIT_NOEXEC	126
#define	EXIT_NOTFOUND	127
#define	EXIT_MISC	127

int
main(int argc, char *argv[])
{
	int exit_status;

	while (getopt(argc, argv, "") != -1)
		usage();
	argc -= optind;
	argv += optind;
	if (argc < 1)
		usage();

	if (isatty(STDOUT_FILENO))
		dofile();
	if (isatty(STDERR_FILENO) && dup2(STDOUT_FILENO, STDERR_FILENO) == -1)
		/* may have just closed stderr */
		err(EXIT_MISC, "%s", argv[0]);

	(void)signal(SIGHUP, SIG_IGN);

	execvp(*argv, argv);
	exit_status = (errno == ENOENT) ? EXIT_NOTFOUND : EXIT_NOEXEC;
	err(exit_status, "%s", argv[0]);
}

static void
dofile(void)
{
	int fd;
	char path[MAXPATHLEN];
	const char *p;

	/*
	 * POSIX mandates if the standard output is a terminal, the standard
	 * output is appended to nohup.out in the working directory.  Failing
	 * that, it will be appended to nohup.out in the directory obtained
	 * from the HOME environment variable.  If file creation is required,
	 * the mode_t is set to S_IRUSR | S_IWUSR.
	 */
	p = FILENAME;
  // 在这里打开 nohup.out 文件
	fd = open(p, O_RDWR | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR);
	if (fd != -1)
    // 如果文件打开成功直接进行文件描述符的替代，将标准输出重定向到文件 nohup.out 
		goto dupit;
	if ((p = getenv("HOME")) != NULL && *p != '\0' &&
	    (size_t)snprintf(path, sizeof(path), "%s/%s", p, FILENAME) <
	    sizeof(path)) {
		fd = open(p = path, O_RDWR | O_CREAT | O_APPEND,
		    S_IRUSR | S_IWUSR);
		if (fd != -1)
			goto dupit;
	}
	errx(EXIT_MISC, "can't open a nohup.out file");

dupit:
	if (dup2(fd, STDOUT_FILENO) == -1)
		err(EXIT_MISC, NULL);
	(void)fprintf(stderr, "appending output to %s\n", p);
}

static void
usage(void)
{
	(void)fprintf(stderr, "usage: nohup [--] utility [arguments]\n");
	exit(EXIT_MISC);
}

在源代码当中的宏 FILENAME 定义的文件名就是 nohup.out，在上面的代码当中，如果判断当前进程的标准输出是一个终端设备就会打开文件 nohup.out 然后将进程的标准输出重定向到文件 nohup.out ，因此我们在程序当中使用 printf 的输出就都会被重定向到文件 nohup.out 当中，看到这里就破案了，原来如此。

后台进程和终端的纠缠

后台进程是不能够从终端读取内容的，当我们从终端当中读的时候内核就会给这个后台进程发送一个 SIGTTIN 信号，这个条件主要是避免多个不同的进程都读终端。如果后台进程从终端当中进行读，那么这个进程就会收到一个 SIGTTIN 信号，这个信号的默认行为就是退出程序。

我们可以使用下面的程序进程测试：

#define _GNU_SOURCE
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>


void sig(int no, siginfo_t* si, void* ucontext)
{
  char s[1024];
  sprintf(s, "signal number = %d sending pid = %d\n", no, si->si_pid);
  write(STDOUT_FILENO, s, strlen(s));
  sync();
  _exit(0);
}

int main()
{
  struct sigaction action;
  action.sa_flags |= SA_SIGINFO;
  action.sa_sigaction = sig;
  action.sa_flags &= ~(SA_RESETHAND);
  sigaction(SIGTTIN, &action, NULL);
  while(1)
  {
    char c = getchar();
  }
  return 0;
}

然后我们在终端输入命令，并且对应的输出如下：

➜  daemon git:(master) ✗ ./job11.out&
[1] 47688
signal number = 21 sending pid = 0                                                                                
[1]  + 47688 done       ./job11.out

从上面程序的输出结果我们可以知道，当我们在程序当中使用函数 getchar 读入字符的时候，程序就会收到来自内核的信号 SIGTTIN，根据下面的信号名和编号表可以知道，内核发送的信号位 SIGTTIN。

当我们在终端当中进行写操作的时候会收到信号 SIGTTOU，但是默认后台进程是可以往终端当中写的，如果我们想要进程不能够往终端当中写，当进程往终端当中写数据的时候就收到信号 SIGTTOU，我们可以使用命令 stty 进行设置。我们使用一个例子看看具体的情况：

#define _GNU_SOURCE
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>


void sig(int no, siginfo_t* si, void* ucontext)
{
  char s[1024];
  sprintf(s, "signal number = %d sending pid = %d\n", no, si->si_pid);
  write(STDOUT_FILENO, s, strlen(s));
  sync();
  _exit(0);
}

int main()
{
  struct sigaction action;
  action.sa_flags |= SA_SIGINFO;
  action.sa_sigaction = sig;
  action.sa_flags &= ~(SA_RESETHAND);
  sigaction(SIGTTOU, &action, NULL);
  while(1)
  {
    sleep(1);
    printf("c");
    fflush(stdout);
  }
  return 0;
}

上面是一个比较简单的信号程序，不断的往终端当中输出字符 c，我们可以看一下程序的执行情况（job12 就是上面的代码）：

➜  daemon git:(master) ✗ stty tostop 
➜  daemon git:(master) ✗ ./job12.out&
[1] 48467
➜  daemon git:(master) ✗ signal number = 22 sending pid = 0

[1]  + 48467 done       ./job12.out

在上面的输出结果当中我们使用命令 stty tostop 主要是用于启动当有后台进程往终端当中写内容的时候，向这个进程发送 SIGTTOU 信号，这个信号的默认行为也是终止进程的执行。

首先看一下当我们没有使用 stty tostop 命令的时候程序的行为。

现在我们使用 stty tostop 命令重新设置一下终端的属性，然后重新进程测试：

从上面的输出结果我们可以看到当我们在终端当中，默认是允许进程往终端当中进行输出的，但是当我们使用命令 stty tostop 之后，如果还有后台进程往终端当中进行输出，那么这个进程就会收到一个 SIGTTOU 信号。

后台进程和终端的命令交互

在前文当中我们谈到了当我们在一条命令后面加上 & 的话，那么这个程序将会变成后台进程。那么有没有办法将一个后台进程变成前台进程呢？

当然有办法，我们可以使用 fg ——一个 shell 的内置命令，将一个后台进程变成前台进程。在正式进行验证之前我们需要来了解三个命令：

• jobs 这条命令主要是用于查看当前所有的后台进程组，也就是所有的后台作业,。
• fg 这条命令主要是将一个后台进程放到前台来运行。
• bg 这条命令主要是让一个终端的后台程序继续执行。

具体的例子如下所示：

➜  daemon git:(master) ✗ sleep 110 & # 创建一个后台进程 每当创建一个后台作业 shell 都会给这个作业分配一个作业号 就是 [] 当中的数字，从 1 开始
[1] 7467
➜  daemon git:(master) ✗ sleep 111 & # 创建一个后台进程
[2] 7485
➜  daemon git:(master) ✗ sleep 112 & # 创建一个后台即成
[3] 7503
➜  daemon git:(master) ✗ jobs # 查看所有的后台进程 其中 + 表示当前作业 可以认为是最近一次使用 & 生成的作业 - 表示上一个作业 可以认为是倒数第二个使用 & 生成的作业
[1]    running    sleep 110
[2]  - running    sleep 111
[3]  + running    sleep 112
➜  daemon git:(master) ✗ fg # fg 的使用方式为 fg %num 如果不指定 %num 的话，默认就是将当前作业放到前台 饿我们在上面已经谈到了 当前作业为 sleep 112 因此将这个进程恢复到前台
[3]  - 7503 running    sleep 112
^C # 终止这个作业
➜  daemon git:(master) ✗ jobs  # 因为终止了作业 sleep 112 因此后台进程组只剩下两个了
[1]    running    sleep 110
[2]  + running    sleep 111
➜  daemon git:(master) ✗ fg  # 在将最近一次提交的作业放到前台
[2]  - 7485 running    sleep 111
^C # 终止这个任务的执行
➜  daemon git:(master) ✗ sleep 112 &
[2] 7760
➜  daemon git:(master) ✗ jobs 
[1]  - running    sleep 110
[2]  + running    sleep 112
➜  daemon git:(master) ✗ sleep 112 &
[3] 7870
➜  daemon git:(master) ✗ sleep 112 &
[4] 7888
➜  daemon git:(master) ✗ jobs 
[1]    running    sleep 110
[2]    running    sleep 112
[3]  - running    sleep 112
[4]  + running    sleep 112
➜  daemon git:(master) ✗ fg %1 
[1]    7467 running    sleep 110
^C
➜  daemon git:(master) ✗ 

接下来我们使用下面的程序进行验证，下面的程序的主要目的就是判断当前进程是否是前台进程，如果是则打印消息，如果不是那么就一直进行死循环：

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

int main()
{
  while(1)
  {
    sleep(1);
    // tcgetpgrp 返回前台进程组的进程组号
    // getpgid(0) 得到当前进程组的进程组号
    // 如果两个结果相等则说明当前进程组是前台进程组
    // 反之则是后台进程组
    if(getpgid(0) == tcgetpgrp(STDOUT_FILENO))
    {
      printf("I am a process of foregroup process\n");
    }
  }
  return 0;
}

然后我们在终端当中执行这个程序，对应的几个结果如下所示：

➜  daemon git:(master) ✗ ./job13.out& # 先将这个程序放到后台运行，因为不是前台程序因此不会打印消息
[1] 5832
➜  daemon git:(master) ✗ fg    # 将这个程序放到前台执行，因为到了前台因此上面的程序会输出消息
[1]  + 5832 running    ./job13.out
I am a process of foregroup process
I am a process of foregroup process
I am a process of foregroup process
^Z
[1]  + 5832 suspended  ./job13.out # 在这里我们按下 ctrl + z 给进程发送 SIGTSTP 信号 让进程暂停执行
➜  daemon git:(master) ✗ bg %1 # bg 命令默认是给进程发送一个 SIGCONT 因为在上一行当中信号 SIGTSTP 让进程暂停执行了 因此进程在收到信号 SIGCONT 之后会继续执行（SIGCONT 的作用就是让一个暂停的进程继续执行）
[1]  + 5832 continued  ./job13.out # 因为进程还是在后台当中，因此进程继续执行还是在后台执行，所以依然没有输出
➜  daemon git:(master) ✗ fg %1 # 这条命令是让后台进程组当中的第一个作业到前台执行，因此进程开始打印输出
[1]  + 5832 running    ./job13.out
I am a process of foregroup process
I am a process of foregroup process
^C # 在这里输入 ctrl + c 命令，让前台进程组当中所有进程停止执行
➜  daemon git:(master) ✗ 

在上面的输出结果当中，我们首先在后台启动一个进程，因为是在后台所以当前进程组不是前台进程组，因此不会在终端当中打印输出，而当我们使用 fg 命令将后台当中的最近生成的一个作业（当我们输入命令之后，终端打印的[]当中的数字就是表示作业号，默认是从 1 开始的，因为我们只启动一个后台进程（执行一条命令就是开启一个作业），因此作业号等于 1）放到前台来执行，在上面的例子当中，命令 fg 和 fg %1 的效果是一样的。

总结

在本篇文章当中主要给大家介绍了后台进程的一些生与死的情况，总体来说有以下内容：

• 当我们退出终端的时候，shell 会给所有前台和后台进程组发送一个 SIGHUP 信号，nohup 命令的原理就是让程序忽略这个 SIGHUP 信号。
• 当后台进程从终端当中读的时候内核会给这个进程发送一个 SIGTTIN 信号。
• 当我们设置了 ssty tostop 之后，如果我们往终端当中进行写操作的话，那么内核会给这个进程发送一个 SIGTTOU 信号，这两个信号的默认行为都是终止这个进程的执行。
• 我们可以使用 jobs fg bg 命令让终端和后台进程进行交互操作，fg 将一个后台进程放到前台执行，如果这个进行暂停执行的话， shell 还会给这个进程发送一个 SIGCONT 信号让这个进程继续执行，bg 可以让一个后台暂停执行的进程恢复执行，本质也是给这个后台进程发送一个 SIGCONT 信号。
• 当你在终端当中输入 ctrl + c 的时候，内核会给所有的前台进程组当中所有的进程发送 SIGINT 信号，当你在终端输入 ctrl + z 时，内核会给前台进程组当中的所有进程发送 SIGTSTP 信号，当你在终端输入 ctrl + \ 内核会给所有的前台进程组发送 SIGQUIT 信号。
• 综合上面的分析，上面的结果可以使用下面的图进行表示分析。

以上就是本篇文章的所有内容了，我是LeHung，我们下期再见！！！更多精彩内容合集可访问项目：https://github.com/Chang-LeHung/CSCore

关注公众号：一无是处的研究僧，了解更多计算机（Java、Python、计算机系统基础、算法与数据结构）知识。