Linux C语言程序设计(十五)——进程、线程与信号

1、进程

1.1 基本概念

每个进程在内核中都有一个进程控制块（ PCB）来维护进程相关的信息， Linux内核的进程控制块是task_struct结构体。

进程ID：统中每个进程有唯一的id，在C语言中用pid_t类型表示，其实就是一个非负整数。

进程状态：有运行、挂起、停止、僵尸等状态。

当前工作目录

1.2 fork

fork的作用是根据一个现有的进程复制出一个新进程，原来的进程称为父进程（ Parent Process） ，新进程称为子进程（ ChildProcess） 。

个进程在调用exec前后也可以分别执行两个不同的程序，例如在Shell提示符下输入命令ls，首先fork创建子进程，这时子进程仍在执行/bin/bash程序，然后子进程调用exec执行新的程序/bin/ls

#include 
#include 
pid_t fork(void);

fork调用失败则返回-1，调用成功的返回值见下面的解释。我们通过一个例子来理解fork是怎样创建新进程的。

#include 
#include 
#include 
#include 
int main(void)
{
	pid_t pid;
	char *message;
	int n;
	pid = fork();
	if (pid < 0) {
		perror("fork failed");
		exit(1);
	}
	if (pid == 0) {
		message = "This is the child\n";
		n = 6;
	} else {
		message = "This is the parent\n";
		n = 3;
	}
	for(; n > 0; n--) {
		printf(message);
		sleep(1);
	}
	return 0;
}

1.3 exec函数

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

#include 
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 execve(const char *path, char *const argv[], char *const envp[]);

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

不带字母p（表示path）的exec函数第一个参数必须是程序的相对路径或绝对路径带有字母l（表示list）的exec函数要求将新程序的每个命令行参数都当作一个参数传给它，命令行参数的个数是可变的，因此函数原型中有...， ...中的最后一个可变参数应该是NULL，起sentinel的作用。

对于以e（表示environment）结尾的exec函数，可以把一份新的环境变量表传给它，其他exec函数仍使用当前的环境变量表执行新程序。

#include 
#include 
int main(void)
{
	execlp("ps", "ps", "-o","pid,ppid,pgrp,session,tpgid,comm", NULL);
	perror("exec ps");
	exit(1);
}

1.4 进程间通信

每个进程各自有不同的用户地址空间，任何一个进程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（ IPC， InterProcess Communication）

管道是一种最基本的IPC机制，由pipe函数创建：

#include 
int pipe(int filedes[2]);

调用pipe函数时在内核中开辟一块缓冲区（称为管道）用于通信，它有一个读端一个写端，然后通过filedes参数传出给用户程序两个文件描述符， filedes[0]指向管道的读端， filedes[1]指向管道的写端（很好记，就像0是标准输入1是标准输出一样）。

所以管道在用户程序看起来就像一个打开的文件，通过read(filedes[0]);或者write(filedes[1]);向这个文件读写数据其实是在读写内核缓冲区。 pipe函数调用成功返回0，调用失败返回-1。

2、线程

2.1 线程的概念

进程在各自独立的地址空间中运行，进程之间共享数据需要用mmap或者进程间通信机制，有些情况需要在一个进程中同时执行多个控制流程，这时候线程就派上了用场。比如我们在使用QQ聊天的时候也可以听音乐，还可以办公写文档。

这些任务都需要一个“等待-处理”的循环，可以用多线程实现，一个线程专门负责与用户交互，另外几个线程每个线程负责和一个网络主机通信。

2.2 线程控制

1）创建线程

#include 
int pthread_create(pthread_t *restrict thread,
const pthread_attr_t *restrict attr,
void *(*start_routine)(void*), void *restrict arg);

返回值：成功返回0，失败返回错误号。以前学过的系统函数都是成功返回0，失败返回-1，而错误号保存在全局变量errno中，而pthread库的函数都是通过返回值返回错误号，虽然每个线程也都有一个errno，但这是为了兼容其它函数接口而提供的， pthread库本身并不使用它，通过返回值返回错误码更加清晰。

2）终止线程

如果需要只终止某个线程而不终止整个进程，可以有三种方法：

从线程函数return（对于main线程除外）。
一个线程可以调用pthread_cancel终止同一进程中的另一个线程。
线程可以调用pthread_exit终止自己。

2.3 线程间同步

1）互斥锁mutex

多个线程同时访问共享数据时可能会冲突，对于多线程的程序，访问冲突的问题是很普遍的，解决的办法是引入互斥锁。获得锁的线程可以完成“读-修改-写”的操作，然后释放锁给其它线程，没有获得锁的线程只能等待而不能访问共享数据，这样“读-修改-写”三步操作组成一个原子操作，要么都执行，要么都不执行，不会执行到中间被打断，也不会在其它处理器上并行做这个操作。

互斥锁Mutex用pthread_mutex_t类型的变量表示，可以这样初始化和销毁：

#include 
int pthread_mutex_destroy(pthread_mutex_t *mutex);
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

返回值：成功返回0，失败返回错误号。Mutex的加锁和解锁操作可以用下列函数：

#include 
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

返回值：成功返回0，失败返回错误号。

2）条件变量Condition Variable

        线程间的同步还有这样一种情况：线程A需要等某个条件成立才能继续往下执行，现在这个条件不成立，线程A就阻塞等待，而线程B在执行过程中使这个条件成立了，就唤醒线程A继续执行。

        在pthread库中通过条件变量（ Condition Variable） 来阻塞等待一个条件，或者唤醒等待这个条件的线程。 Condition Variable用pthread_cond_t类型的变量表示，可以这样初始化和销毁：

#include 
int pthread_cond_destroy(pthread_cond_t *cond);
int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict attr);
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

返回值：成功返回0，失败返回错误号。Condition Variable的操作可以用下列函数：

#include 
int pthread_cond_timedwait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex,const struct timespec *restrict abstime);
int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);
int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_signal(pthread_cond_t *cond);

返回值：成功返回0，失败返回错误号。一个Condition Variable总是和一个Mutex搭配使用的。一个线程可以调用pthread_cond_wait在一个Condition Variable上阻塞等待，这个函数做以下三步操作：1.释放Mutex  2. 阻塞等待  3. 当被唤醒时，重新获得Mutex并返回

3）信号量Semaphore

        Mutex变量是非0即1的，可看作一种资源的可用数量，初始化时Mutex是1，表示有一个可用资源，加锁时获得该资源，将Mutex减到0，表示不再有可用资源，解锁时释放该资源，将Mutex重新加到1，表示又有了一个可用资源。信号量（ Semaphore） 和Mutex类似，表示可用资源的数量，和Mutex不同的是这个数量可以大于1。

POSIX semaphore库函数：

#include 
int sem_init(sem_t *sem, int pshared, unsigned int value);
int sem_wait(sem_t *sem);
int sem_trywait(sem_t *sem);
int sem_post(sem_t * sem);
int sem_destroy(sem_t * sem);

semaphore变量的类型为sem_t， sem_init()初始化一个semaphore变量， value参数表示可用资源的数量， pshared参数为0表示信号量用于同一进程的线程间同步

2.4 其它线程间同步机制

        如果共享数据是只读的，那么各线程读到的数据应该总是一致的，不会出现访问冲突。只要有一个线程可以改写数据，就必须考虑线程间同步的问题。由此引出了读者写者锁（ ReaderWriter Lock）的概念， Reader之间并不互斥，可以同时读共享数据，而Writer是独占的（ exclusive），在Writer修改数据时其它Reader或Writer不能访问数据，可见Reader-WriterLock比Mutex具有更好的并发性。

        用挂起等待的方式解决访问冲突不见得是最好的办法，因为这样毕竟会影响系统的并发性，在某些情况下解决访问冲突的问题可以尽量避免挂起某个线程，例如Linux内核的Seqlock、 RCU（ read-copy-update）等机制。

3、信号

3.1 信号基本概念

1）场景导入

为了理解信号，先从我们最熟悉的场景说起：

1. 用户输入命令，在Shell下启动一个前台进程。
2. 用户按下Ctrl-C，这个键盘输入产生一个硬件中断。
3. 如果CPU当前正在执行这个进程的代码，则该进程的用户空间代码暂停执行， CPU从用户态切换到内核态处理硬件中断。
4. 终端驱动程序将Ctrl-C解释成一个SIGINT信号，记在该进程的PCB中（也可以说发送了一个SIGINT信号给该进程）。
5. 当某个时刻要从内核返回到该进程的用户空间代码继续执行之前，首先处理PCB中记录的信号，发现有一个SIGINT信号待处理，而这个信号的默认处理动作是终止进程，所以直接终止进程而不再返回它的用户空间代码执行。

2）场景解析

        Shell可以同时运行一个前台进程和任意多个后台进程，只有前台进程才能接到像Ctrl-C这种控制键产生的信号。前台进程在运行过程中用户随时可能按下Ctrl-C而产生一个信号，也就是说该进程的用户空间代码执行到任何地方都有可能收到SIGINT信号而终止，所以信号相对于进程的控制流程来说是异步（ Asynchronous） 的。

        每个信号都有一个编号和一个宏定义名称，这些宏定义可以在signal.h中找到，例如其中有定义#define SIGINT 2。编号34以上的是实时信号，我们这里不讨论实时信号。

        信号一般有这样的四个参数：Signal（宏定义名称） Value（信号的编号） Action（默认处理动作） Comment（简要介绍、描述）

        信号的动作含义常见的：Term表示终止当前进程， Core表示终止当前进程，Ign表示忽略该信号， Stop表示停止当前进程， Cont表示继续执行先前停止的进程

3.2 产生信号

1 用户在终端按下某些键时，比如用户按下Ctrl-C产生SIGINT信号， Ctrl-\产生SIGQUIT信号， Ctrl-Z产生SIGTSTP信号等

2 硬件异常产生信号，这些条件由硬件检测到并通知内核，然后内核向当前进程发送适当的信号。

3 一个进程调用kill(2)函数可以发送信号给另一个进程。

4 当内核检测到某种软件条件发生时也可以通过信号通知进程，例如闹钟超时产生SIGALRM信号，向读端已关闭的管道写数据时产生SIGPIPE信号。

对于产生的信号，可以选择性处理，比如让它执行默认动作或者忽略信号等操作都是可行的。

3.3 阻塞信号

1）信号内核表示

        以上我们讨论了信号产生（ Generation）的各种原因，而实际执行信号的处理动作称为信号递达（ Delivery），信号从产生到递达之间的状态，称为信号未决（ Pending）。进程可以选择阻塞（ Block）某个信号。

        被阻塞的信号产生时将保持在未决状态，直到进程解除对此信号的阻塞，才执行递达的动作。注意，阻塞和忽略是不同的，只要信号被阻塞就不会递达，而忽略是在递达之后可选的一种处理动作。

        每个信号都有两个标志位分别表示阻塞和未决，还有一个函数指针表示处理动作。信号产生时，内核在进程控制块中设置该信号的未决标志，直到信号递达才清除该标志。

        如果在进程解除对某信号的阻塞之前这种信号产生过多次，将如何处理？ Linux是这样实现的：常规信号在递达之前产生多次只计一次，而实时信号在递达之前产生多次可以依次放在一个队列里。本章不讨论实时信号。

2）信号集操作函数

        sigset_t类型对于每种信号用一个bit表示“有效”或“无效”状态，至于这个类型内部如何存储这些bit则依赖于系统实现，从使用者的角度是不必关心的，使用者只能调用以下函数来操作sigset_t变量，而不应该对它的内部数据做任何解释，比如用printf直接打印sigset_t变量是没有意义的。

#include 
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset(sigset_t *set, int signo);
int sigdelset(sigset_t *set, int signo);
int sigismember(const sigset_t *set, int signo);

函数sigemptyset初始化set所指向的信号集，使其中所有信号的对应bit清零，表示该信号集不包含任何有效信号。函数sigfillset初始化set所指向的信号集，使其中所有信号的对应bit置位，表示该信号集的有效信号包括系统支持的所有信号。

3）sigprocmask

调用函数sigprocmask可以读取或更改进程的信号屏蔽字。

#include 
int sigprocmask(int how, const sigset_t *set, sigset_t *oset);

返回值：若成功则为0，若出错则为-1

如果oset是非空指针，则读取进程的当前信号屏蔽字通过oset参数传出。如果set是非空指针，则更改进程的信号屏蔽字，参数how指示如何更改。如果oset和set都是非空指针，则先将原来的信号屏蔽字备份到oset里，然后根据set和how参数更改信号屏蔽字。假设当前的信号屏蔽字为mask，下表说明了how参数的可选值。

4）sigpending

sigpending读取当前进程的未决信号集，通过set参数传出。调用成功则返回0，出错则返回-1。

#include 
int sigpending(sigset_t *set);

3.4 捕捉信号

如果信号的处理动作是用户自定义函数，在信号递达时就调用这个函数，这称为捕捉信号。

1）sigaction

#include 
int sigaction(int signo, const struct sigaction *act, struct sigaction *oact);

sigaction函数可以读取和修改与指定信号相关联的处理动作。调用成功则返回0，出错则返回-1。

signo是指定信号的编号。若act指针非空，则根据act修改该信号的处理动作。若oact指针非空，则通过oact传出该信号原来的处理动作。 act和oact指向sigaction结构体：

struct sigaction {
	void (*sa_handler)(int); /* addr of signal handler, or SIG_IGN, or SIG_DFL */
	sigset_t sa_mask; /* additional signals to block*/
	int sa_flags; /* signal options, Figure 10.16 alternate handler */
	void (*sa_sigaction)(int, siginfo_t *, void *);
};

将sa_handler赋值为常数SIG_IGN传给sigaction表示忽略信号，赋值为常数SIG_DFL表示执行系统默认动作，赋值为一个函数指针表示用自定义函数捕捉信号，或者说向内核注册了一个信号处理函数，该函数返回值为void，可以带一个int参数，通过参数可以得知当前信号的编号，这样就可以用同一个函数处理多种信号。

这是一个回调函数，不被main调用，而是被系统所调用。

2）pause

        pause函数使调用进程挂起直到有信号递达。如果信号的处理动作是终止进程，则进程终止， pause函数没有机会返回；如果信号的处理动作是忽略，则进程继续处于挂起状态， pause不返回；如果信号的处理动作是捕捉，则调用了信号处理函数之后pause返回-1， errno设置为EINTR，所以pause只有出错的返回值

#include 
int pause(void);

下面我们用alarm和pause实现sleep(3)函数，称为mysleep。

#include 
#include 
#include 
void sig_alrm(int signo)
{
	/* nothing to do */
}

unsigned int mysleep(unsigned int nsecs)
{
	struct sigaction newact, oldact;
	unsigned int unslept;
	newact.sa_handler = sig_alrm;
	sigemptyset(&newact.sa_mask);
	newact.sa_flags = 0;
	sigaction(SIGALRM, &newact, &oldact);
	alarm(nsecs);
	pause();
	unslept = alarm(0);
	sigaction(SIGALRM, &oldact, NULL);
	return unslept;
}
int main(void)
{
	while(1){
		mysleep(2);
		printf("Two seconds passed\n");
	}
	return 0;
}

1. main函数调用mysleep函数，后者调用sigaction注册了SIGALRM信号的处理函数sig_alrm。
2. 调用alarm(nsecs)设定闹钟。
3. 调用pause等待，内核切换到别的进程运行。
4. nsecs秒之后，闹钟超时，内核发SIGALRM给这个进程。
5. 从内核态返回这个进程的用户态之前处理未决信号，发现有SIGALRM信号，其处理函数是sig_alrm。
6. 切换到用户态执行sig_alrm函数，进入sig_alrm函数时SIGALRM信号被自动屏蔽，从sig_alrm函数返回时SIGALRM信号自动解除屏蔽。然后自动执行系统调用sigreturn再次进入内核，再返回用户态继续执行进程的主控制流程（ main函数调用的mysleep函数）。
7. pause函数返回-1，然后调用alarm(0)取消闹钟，调用sigaction恢复SIGALRM信号以前的处理动作。

3）竞态条件

现在重新审视上面的案例“mysleep”，设想这样的时序：

1. 注册SIGALRM信号的处理函数。
2. 调用alarm(nsecs)设定闹钟。
3. 内核调度优先级更高的进程取代当前进程执行，并且优先级更高的进程有很多个，每个都
要执行很长时间
4. nsecs秒钟之后闹钟超时了，内核发送SIGALRM信号给这个进程，处于未决状态。
5. 优先级更高的进程执行完了，内核要调度回这个进程执行。 SIGALRM信号递达，执行处理
函数sig_alrm之后再次进入内核。
6. 返回这个进程的主控制流程， alarm(nsecs)返回，调用pause()挂起等待。
7. 可是SIGALRM信号已经处理完了，还等待什么呢？

        出现这个问题的根本原因是系统运行的时序（ Timing） 并不像我们写程序时所设想的那样。虽然alarm(nsecs)紧接着的下一行就是pause()，但是无法保证pause()一定会在调用alarm(nsecs)之后的nsecs秒之内被调用。由于异步事件在任何时候都有可能发生（这里的异步事件指出现更高优先级的进程），如果我们写程序时考虑不周密，就可能由于时序问题而导致错误，这叫做竞态条件（ Race Condition） 。

        要是“解除信号屏蔽”和“挂起等待信号”这两步能合并成一个原子操作就好了，这正是sigsuspend函数的功能。 sigsuspend包含了pause的挂起等待功能，同时解决了竞态条件的问题，在对时序要求严格的场合下都应该调用sigsuspend而不是pause。

#include 
int sigsuspend(const sigset_t *sigmask);

        和pause一样， sigsuspend没有成功返回值，只有执行了一个信号处理函数之后sigsuspend才返回，返回值为-1， errno设置为EINTR。

        调用sigsuspend时，进程的信号屏蔽字由sigmask参数指定，可以通过指定sigmask来临时解除对某个信号的屏蔽，然后挂起等待，当sigsuspend返回时，进程的信号屏蔽字恢复为原来的值，如果原来对该信号是屏蔽的，从sigsuspend返回后仍然是屏蔽的。

unsigned int mysleep(unsigned int nsecs)
{
	struct sigaction newact, oldact;
	sigset_t newmask, oldmask, suspmask;
	unsigned int unslept;


	/* set our handler, save previous information */
	newact.sa_handler = sig_alrm;
	sigemptyset(&newact.sa_mask);
	newact.sa_flags = 0;
	sigaction(SIGALRM, &newact, &oldact);


	/* block SIGALRM and save current signal mask */
	sigemptyset(&newmask);
	sigaddset(&newmask, SIGALRM);
	sigprocmask(SIG_BLOCK, &newmask, &oldmask);
	alarm(nsecs);
	suspmask = oldmask;
	sigdelset(&suspmask, SIGALRM); /* make sure SIGALRM isn't blocked */
	sigsuspend(&suspmask); /* wait for any signal to be caught */


	/* some signal has been caught, SIGALRM is now blocked */
	unslept = alarm(0);
	sigaction(SIGALRM, &oldact, NULL); /* reset previous action */
	/* reset signal mask, which unblocks SIGALRM */
	sigprocmask(SIG_SETMASK, &oldmask, NULL);
	return(unslept);
}

如果在调用mysleep函数时SIGALRM信号没有屏蔽：

1. 调用sigprocmask(SIG_BLOCK, &newmask, &oldmask);时屏蔽SIGALRM。
2. 调用sigsuspend(&suspmask);时解除对SIGALRM的屏蔽，然后挂起等待待。
3. SIGALRM递达后suspend返回，自动恢复原来的屏蔽字，也就是再次屏蔽SIGALRM。
4. 调用sigprocmask(SIG_SETMASK, &oldmask, NULL);时再次解除对SIGALRM的屏蔽。