【Linux编程】竞争条件

当多个进程都企图对共享数据进行某种处理，而最后的结果又取决于进程进行的顺序时，则我们认为这发生了竞争条件。一个例子是在fork出子进程之后，父、子进程的执行顺序是不确定的，这种不确定决定了后面程序的结果，那么这便产生了一个竞争条件。

如果一个进程希望等待一个子进程终止，则它必须调用wait或waitpid函数。如果一个进程要等待其父进程终止，则可使用如下的轮询方式：

while (getppid() != 1)
sleep(1);

这样的轮询需要休眠、唤醒等工作，很显然浪费了CPU资源。

如果要消除竞争条件而又不想使用轮询，则有如下两种方法：

信号机制
进程间通信（IPC）
这两种机制以后再讲，先来看看一个包含竞争条件的程序：

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

static void charatatime(char *str)
{
char *ptr;
int c;

setbuf(stdout, NULL);  /* 标准输出设置为不带缓冲 */
for (ptr = str; (c = *ptr++) != 0; )
putc(c, stdout);
}

int main(void)
{
pid_t pid;

pid = fork();
if (pid == 0)
charatatime("output from child\n");
else
charatatime("output from parent\n");

return 0;
}

上述程序由fork产生了一个竞争条件。把标准输出的缓冲区大小设为了0，每输入一个字符就调用一次write系统调用，增大了进程运行时间，为的是让两个进程尽可能的切换。

运行结果：



可以看到，父、子进程交替输出结果。

解决办法1：使用信号

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

static volatile sig_atomic_t sigflag;
static sigset_t newmask, oldmask, zeromask; /* 定义三个信号集 */

static void sig_usr(int signo)
{
sigflag = 1;
}

void TELL_WAIT(void)
{
if (signal(SIGUSR1, sig_usr) == SIG_ERR)
exit(-1);
if (signal(SIGUSR2, sig_usr) == SIG_ERR)
exit(-1);

sigemptyset(&zeromask);         /* 初始化信号集 */
sigemptyset(&newmask);          /* 初始化信号集 */
sigaddset(&newmask, SIGUSR1);  /* 向信号集中添加信号 */
sigaddset(&newmask, SIGUSR2);  /* 向信号集中添加信号 */

/* 更改信号屏蔽字，阻塞SIGUSR1和SIGUSR2两个信号
* SIG_BLOCK表示新的信号屏蔽字是当前信号屏蔽字和第二个参数newmask的并集
* oldmask保存当前的信号屏蔽字，以便稍后恢复用
*/
if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0)
exit(-1);
}

void TELL_PARENT(pid_t pid)
{
kill(pid, SIGUSR2);
}

void WAIT_PARENT(void)
{
while (sigflag == 0)
sigsuspend(&zeromask);  /* 将信号屏蔽字设置为zeromask并在捕捉到信号之前挂起进程 */

sigflag = 0;

/* 恢复信号屏蔽字
* SIG_SETMASK表示新的信号屏蔽字为由oldmask参数提供
*/
if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)
exit(-1);
}

void TELL_CHILD(pid_t pid)
{
kill(pid, SIGUSR1);
}

void WAIT_CHILD(void)
{
while (sigflag == 0)
sigsuspend(&zeromask);

sigflag = 0;

if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)
exit(-1);
}

static void charatatime(char *str)
{
char *ptr;
int c;

setbuf(stdout, NULL);  /* 标准输出设置为不带缓冲 */
for (ptr = str; (c = *ptr++) != 0; )
putc(c, stdout);
}

int main(void)
{
pid_t pid;
TELL_WAIT();

pid = fork();
if (pid == 0)
{
WAIT_PARENT();
charatatime("output from child\n");
}
else
{
charatatime("output from parent\n");
TELL_CHILD(pid);
waitpid(pid, NULL, 0);
}

return 0;
}

这里使用到了信号集的概念，把若干个信号放入一个以sigset_t类型表示的信号集中，然后调用相关接口实现了父、子进程的同步。运行结果如下：



解决办法2：使用管道

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

static int pfd1[2], pfd2[2];

void TELL_WAIT(void)
{
pipe(pfd1);     /* 建立管道1 */
pipe(pfd2);     /* 建立管道2 */
}

void TELL_PARENT(pid_t pid)
{
if (write(pfd2[1], "c", 1) != 1)   /* 写输出描述符 */
exit(-1);
}

void WAIT_PARENT(void)
{
char c;

if (read(pfd1[0], &c, 1) != 1) /* 读输入描述符 */
exit(-1);
if (c != 'p')
exit(-1);
}

void TELL_CHILD(pid_t pid)
{
if (write(pfd1[1], "p", 1) != 1)   /* 写输出描述符 */
exit(-1);
}

void WAIT_CHILD(void)
{
char c;

if (read(pfd2[0], &c, 1) != 1) /* 读输入描述符 */
exit(-1);
if (c != 'c')
exit(-1);
}

static void charatatime(char *str)
{
char *ptr;
int c;

setbuf(stdout, NULL);  /* 标准输出设置为不带缓冲 */
for (ptr = str; (c = *ptr++) != 0; )
putc(c, stdout);
}

int main(void)
{
pid_t pid;
TELL_WAIT();

pid = fork();
if (pid == 0)
{
WAIT_PARENT();
charatatime("output from child\n");
}
else
{
charatatime("output from parent\n");
TELL_CHILD(pid);
waitpid(pid, NULL, 0);
}

return 0;
}

上述程序会建立如下进程关系：



处于等待的子进程调用read函数并阻塞，等待父进程发送字符。运行结果如下：



参考：
《unix环境高级编程》 P185-P188、P256-P273、P398-P403.