为了防止出现因多个程序同时访问一个共享资源而引发的一系列问题，我们需要一种方法，它可以通过生成并使用令牌来授权，在任一时刻只能有一个执行线程访问代码的临界区域。临界区域是指执行数据更新的代码需要独占式地执行。而信号量就可以提供这样的一种访问机制，让一个临界区同一时间只有一个线程在访问它，也就是说信号量是用来调协进程对共享资源的访问的。

信号量是一个特殊的变量，程序对其访问都是原子操作，且只允许对它进行等待（即P) 和发送（即V) 信息操作。最简单的信号量是只能取 0 和 1 的变量，这也是信号量最常见的一种形式，叫做二进制信号量。而可以取多个正整数的信号量被称为通用信号量。这里主要讨论二进制信号量。

由于信号量只能进行两种操作等待和发送信号，即 P(sv) 和 V(sv),他们的行为是这样的：

P(sv)：如果sv的值大于零，就给它减 1；如果它的值为零，就挂起该进程的执行

V(sv)：如果有其他进程因等待sv而被挂起，就让它恢复运行，如果没有进程因等待sv而挂起，就给它加 1.

举个例子，就是两个进程共享信号量sv，一旦其中一个进程执行了P(sv)操作，它将得到信号量，并可以进入临界区，使sv减 1。而第二个进程将被阻止进入临界区，因为当它试图执行P(sv)时，sv为 0，它会被挂起以等待第一个进程离开临界区域并执行V(sv)释放信号量，这时第二个进程就可以恢复执行。

本文代码同步在这里。

相关函数

Linux 提供了一组精心设计的信号量接口来对信号进行操作，它们不只是针对二进制信号量，下面将会对这些函数进行介绍，但请注意，这些函数都是用来对成组的信号量值进行操作的。它们声明在头文件 sys/sem.h 中。

semget()

它的作用是创建一个新信号量或取得一个已有信号量，原型为：

int semget(key_t key, int num_sems, int sem_flags);

• key是整数值（唯一非零），不相关的进程可以通过它访问一个信号量，它代表程序可能要使用的某个资源，程序对所有信号量的访问都是间接的，程序先通过调用semget()函数并提供一个键，再由系统生成一个相应的信号标识符（semget()函数的返回值），只有semget()函数才直接使用信号量键，所有其他的信号量函数使用由semget()函数返回的信号量标识符。如果多个程序使用相同的key值，key将负责协调工作。

• num_sems指定需要的信号量数目，它的值几乎总是 1。

• sem_flags是一组标志，当想要当信号量不存在时创建一个新的信号量，可以和值IPC_CREAT做按位或操作。设置了IPC_CREAT标志后，即使给出的键是一个已有信号量的键，也不会产生错误。而IPC_CREAT | IPC_EXCL则可以创建一个新的，唯一的信号量，如果信号量已存在，返回一个错误。

semget()函数成功返回一个相应信号标识符（非零），失败返回-1.

semop()

它的作用是改变信号量的值，原型为：

int semop(int sem_id, struct sembuf *sem_opa, size_t num_sem_ops);

• sem_id是由semget()返回的信号量标识符，sembuf结构的定义如下：

  struct sembuf{
      short sem_num; // 除非使用一组信号量，否则它为0
      short sem_op;  // 信号量在一次操作中需要改变的数据，通常是两个数，一个是-1，即 P（等待）操作，
                  // 一个是+1，即V（发送信号）操作。
      short sem_flg; // 通常为 SEM_UNDO，使操作系统跟踪信号，
                  // 并在进程没有释放该信号量而终止时，操作系统释放信号量
  };
  

• num_sem_ops：操作sops中的操作个数，通常取值为 1

semctl()

该函数用来直接控制信号量信息，它的原型为：

int semctl(int sem_id, int sem_num, int command, ...);

• 如果有第四个参数，它通常是一个union semum结构，定义如下：

  union semun {
      int val;
      struct semid_ds *buf;
      unsigned short *arry;
  };
  

• 前两个参数与前面一个函数中的一样，command通常是下面两个值中的其中一个

• SETVAL：用来把信号量初始化为一个已知的值。p 这个值通过 union semun 中的 val 成员设置，其作用是在信号量第一次使用前对它进行设置。

• IPC_RMID：用于删除一个已经无需继续使用的信号量标识符。

消息队列提供了一种从一个进程向另一个进程发送一个数据块的方法。

每个数据块都被认为含有一个类型，接收进程可以独立地接收含有不同类型的数据结构。我们可以通过发送消息来避免命名管道的同步和阻塞问题。但是消息队列与命名管道一样，每个数据块都有一个最大长度的限制。

本文代码同步在这里。

相关函数

msgget()

该函数用来创建和访问一个消息队列。它的原型为：

int msgget(key_t, key, int msgflg);

• key：与其他的 IPC 机制一样，程序必须提供一个键来命名某个特定的消息队列。
• msgflg是一个权限标志，表示消息队列的访问权限，它与文件的访问权限一样。msgflg可以与IPC_CREAT做或操作，表示当 key 所命名的消息队列不存在时创建一个消息队列，如果 key 所命名的消息队列存在时，IPC_CREAT标志会被忽略，而只返回一个标识符。

它返回一个以key命名的消息队列的标识符（非零整数），失败时返回-1.

msgsnd()

该函数用来把消息添加到消息队列中。它的原型为：

int msgsend(int msgid, const void *msg_ptr, size_t msg_sz, int msgflg);

• msgid是由msgget函数返回的消息队列标识符。

• msg_ptr是一个指向准备发送消息的指针，但是消息的数据结构却有一定的要求，指针msg_ptr所指向的消息结构一定要是以一个长整型成员变量开始的结构体，接收函数将用这个成员来确定消息的类型。所以消息结构要定义成这样：

  struct my_message {
      long int message_type;
      /* The data you wish to transfer */
  };
  

• msg_sz 是msg_ptr指向的消息的长度

• msgflg 用于控制当前消息队列满或队列消息到达系统范围的限制时将要发生的事情

• 如果调用成功，消息数据的副本将被放到消息队列中，并返回0，失败时返回-1.

msgrcv()

该函数用来从一个消息队列获取消息，它的原型为

int msgrcv(int msgid, void *msg_ptr, size_t msg_st, long int msgtype, int msgflg);

• 前三个参数参照前面的解释
• msgtype 可以实现一种简单的接收优先级。如果msgtype为0，就获取队列中的第一个消息。如果它的值大于零，将获取具有相同消息类型的第一个信息。如果它小于零，就获取类型等于或小于msgtype的绝对值的第一个消息。
• msgflg 用于控制当队列中没有相应类型的消息可以接收时将发生的事情。
• 调用成功时，该函数返回放到接收缓存区中的字节数，消息被复制到由msg_ptr指向的用户分配的缓存区中，然后删除消息队列中的对应消息。失败时返回-1。

msgctl()

该函数用来控制消息队列，它与共享内存的shmctl函数相似，它的原型为：

int msgctl(int msgid, int command, struct msgid_ds *buf);

• msgid同上

• command是将要采取的动作，它可以取3个值:

  • IPC_STAT：把msgid_ds结构中的数据设置为消息队列的当前关联值，即用消息队列的当前关联值覆盖msgid_ds的值。
  • IPC_SET：如果进程有足够的权限，就把消息列队的当前关联值设置为msgid_ds结构中给出的值
  • IPC_RMID：删除消息队列

• buf是指向msgid_ds结构的指针，它指向消息队列模式和访问权限的结构。msgid_ds结构至少包括以下成员：

  struct msgid_ds
  {
      uid_t shm_perm.uid;
      uid_t shm_perm.gid;
      mode_t shm_perm.mode;
  };
  

• 成功时返回 0，失败时返回 -1.

Demo

//msgsnd
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/msg.h>

#define MAX_TXT 512

struct msg_st
{
    long int msg_type;
    char msg[MAX_TXT];
};

int main()
{
    struct msg_st message;
    int msgid = 1;
    char buffer[BUFSIZ];
    key_t msgKey = ftok("./msgsnd.c", 0);
    msgid = msgget(msgKey, 0666 | IPC_CREAT);

    if (msgid == -1)
    {
        fprintf(stderr, "masget failed error: %d\n", errno);
        exit(EXIT_FAILURE);
    }
    while (1)
    {
        printf("Enter some text: \n");
        fgets(buffer, BUFSIZ, stdin);
        message.msg_type = 1; // 注意 2
        strcpy(message.msg, buffer);

        // 向队列里发送数据
        if (msgsnd(msgid, (void *)&message, MAX_TXT, 0) == -1)
        {
            fprintf(stderr, "msgsnd failed\n");
            exit(EXIT_FAILURE);
        }

        // 输入 end 结束输入
        if (strncmp(buffer, "end", 3) == 0)
        {
            break;
        }

        sleep(1);
    }

    exit(EXIT_SUCCESS);
}

//msgrcv
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <sys/msg.h>

#define MAX_TXT 512

struct msg_st
{
    long int msg_type;
    char msg[MAX_TXT];
};

int main()
{
    struct msg_st message;
    int msgid = 1;
    long int msgtype = 0;
    key_t msgKey = ftok("./msgsnd.c", 0);
    msgid = msgget(msgKey, 0666 | IPC_CREAT);

    if (msgid == -1)
    {
        fprintf(stderr, "masget failed error: %d\n", errno);
        exit(EXIT_FAILURE);
    }
    while (1)
    {
        if (msgrcv(msgid, (void *)&message, BUFSIZ, msgtype, 0) == -1)
        {
            fprintf(stderr, "msgsnd failed\n");
            exit(EXIT_FAILURE);
        }

        printf("You wrote: %s\n", message.msg);

        if (strncmp(message.msg, "end", 3) == 0)
        {
            break;
        }
    }

    exit(EXIT_SUCCESS);
}

运行结果

本文通过实例介绍通过共享内存实现进程间通信。

简介

信号就像实际生产过程中的应急预案，发生了某个异常就会启动特定的应急预案，为了响应各类异常情况，所以就定义了很多个信号，信号的名称是在头文件signal.h中定义的，信号都以SIG开头，常用的信号并不多，常用的信号如下：

SIGALRM     #时钟定时信号, 计算的是实际的时间或时钟时间
SIGHUP      #终端的挂断或进程死亡
SIGINT      #来自键盘的中断信号
SIGKILL     #用来立即结束程序的运行. 本信号不能被阻塞、处理和忽略。
SIGPIPE     #管道破裂
SIGTERM     #程序结束(terminate)信号, 与SIGKILL不同的是该信号可以被阻塞和处理
SIGUSR1,SIGUSR2     #留给用户使用

实例

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

void signalHandler(int sig)
{
    printf("\nOps! - I got signal %d\n", sig);

    // 恢复终端中断信号 SIGINT 的默认行为
    (void)signal(SIGINT, SIG_DFL);
}

int main()
{
    // 改变终端中断信号 SIGINT 的默认行为，使之执行 ouch 函数
    // 而不是终止程序的执行
    (void)signal(SIGINT, signalHandler);
    while (1)
    {
        printf("Hello World!\n");
        sleep(1);
    }

    return 0;
}

我们可以用signal()函数处理指定的信号，主要通过忽略和恢复其默认行为来工作。signal() 函数的原型如下：

void (*signal(int sig, void (*func)(int)))(int);

这是一个相当复杂的声明，耐心点看可以知道 signal 是一个带有sig和func两个参数的函数，func是一个类型为void (*)(int)的函数指针。该函数返回一个与func相同类型的指针，指向先前指定信号处理函数的函数指针。准备捕获的信号的参数由sig给出，接收到的指定信号后要调用的函数由参数func给出。其实这个函数的使用是相当简单的，通过下面的例子就可以知道。注意信号处理函数的原型必须为void func（int），或者是下面的特殊值：

SIG_IGN : 忽略信号
SIG_DFL : 恢复信号的默认行为

我们程序的目的是想要捕获键盘输入Ctrl+C，这个中断。通过表里可以查到，我们使用SIGINT这个信号，当我们的程序出现SIGINT信号时，让程序接下来干啥呢？正常情况下，我们的Ctrl+C会中断当前运行的程序，但是现在我们做了一些更改，更改的内容在我们自己编写的signalHandler中。我们让程序输出一行字符串加上信号值。然后再把信号的行为恢复原样。此时我们运行程序可以得到如下

在我们第一输入Ctrl+C时，程序没有中断，而是调用了signalHanlder函数，因为我们更改了信号的行为。但是第二次输入Ctrl+C时，程序中断了。

本文通过实例介绍通过共享内存实现进程间通信。

shmget(得到一个共享内存标识符或创建一个共享内存对象)

我们可以通过shmget函数创建或打开共享内存，通过函数签名

//key_t key:  唯一定位一个共享内存对象
//size_t size: 共享内存大小
//int flag: 如果是 IPC_CREAT 表示创建新的共享内存空间
int shmget(key_t key, size_t size, int flag);

• 第一个参数是共享内存的唯一标识，是需要我们指定的。那么如何指定key呢？如何保证唯一性呢？我们可以指定一个文件，ftok会根据这个文件的 inode，生成一个近乎唯一的 key。只要在这个消息队列的生命周期内，这个文件不要被删除就可以了。只要不删除，无论什么时刻，再调用 ftok，也会得到同样的key。
• 第二个参数是申请的空间大小，我们就申请 1024B。
• 第三个参数是权限标识，IPC_CREAT表示创建共享内存，0644表示允许一个进程创建的共享内存被内存创建者所拥有的进程向共享内存读取和写入数据，同时其他用户创建的进程只能读取共享内存。

shmat(把共享内存区对象映射到调用进程的地址空间)

第一次创建完共享内存时，它还不能被任何进程访问，shmat()函数的作用就是用来启动对该共享内存的访问，并把共享内存连接到当前进程的地址空间。它的签名如下：

void *shmat(int shm_id, const void *shm_addr, int shmflg);

• 第一个参数就是上文产生的唯一标识。
• 第二个参数，shm_addr指定共享内存连接到当前进程中的地址位置，通常为空，表示让系统来选择共享内存的地址。
• 第三个参数，shm_flg是一组标志位，通常为 0。 调用成功时返回一个指向共享内存第一个字节的指针，如果调用失败返回-1.

(void *) - 1把-1转换为指针0xFFFFFFFF，有时也会用到(void*)0，表示一个空指针。

shmdt(断开共享内存连接)

与 shmat 函数相反，是用来断开与共享内存附加点的地址，禁止本进程访问此片共享内存

函数签名如下：

int shmdt(const void *shmaddr)

• 参数一shmaddr为连接共享内存的起始地址。

需要注意的是，本函数调用并不删除所指定的共享内存区，而只是将先前用 shmat 函数连接（attach）好的共享内存脱离（detach）目前的进程。删除共享内存就需要下面的这个函数。

shmctl(共享内存管理)

完成对共享内存的控制，包括改变状态，删除共享内存等。

函数签名如下：

int shmctl(int shmid, int cmd, struct shmid_ds *buf)

• shmid共享内存唯一标识符
• cmd执行的操作，包括如下
  • IPC_STAT：得到共享内存的状态，把共享内存的shmid_ds结构复制到buf中
  • IPC_SET：改变共享内存的状态，把buf所指的shmid_ds结构中的uid、gid、mode复制到共享内存的shmid_ds结构内
  • IPC_RMID：删除这片共享内存
• buf共享内存管理结构体。具体说明参见共享内存内核结构定义部分

//server.c
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int shmid;
    key_t shmkey;
    char *shmptr;
    shmkey = ftok("./client.c", 0);
    // 创建或打开内存共享区域
    shmid = shmget(shmkey, 1024, 0666 | IPC_CREAT);
    if (shmid == -1)
    {
        printf("shmget error!\n");
        exit(1);
    }

    //将共享内存映射到当前进程的地址中，
    //之后直接对进程中的地址 addr 操作就是对共享内存操作
    shmptr = (char *)shmat(shmid, NULL, 0);
    if (shmptr == (void *)-1)
    {
        printf("shmat error!\n");
        exit(1);
    }

    while (1)
    {
        // 把用户的输入存到共享内存区域中
        printf("input:");
        scanf("%s", shmptr);
    }
    exit(0);
}

//client.c
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(void)
{
    int shmid;
    char *shmptr;
    key_t shmkey;
    shmkey = ftok("./client.c", 0);
    // 创建或打开内存共享区域
    shmid = shmget(shmkey, 1024, 0666 | IPC_CREAT);
    if (shmid == -1)
    {
        printf("shmget error!\n");
        exit(1);
    }

    //将共享内存映射到当前进程的地址中，
    //之后直接对进程中的地址 addr 操作就是对共享内存操作
    shmptr = (char *)shmat(shmid, NULL, 0);
    if (shmptr == (void *)-1)
    {
        fprintf(stderr, "shmat error!\n");
        exit(1);
    }

    while (1)
    {
        // 每隔 3 秒从共享内存中取一次数据并打印到控制台
        printf("string:%s\n", shmptr);
        sleep(3);
    }
    exit(0);
}

在两个终端分别运行client和server，client会每三秒在终端打印出server输入的内容。

如何手动删除共享内存？

列出所有的共享内存段：

ipcs -m
------------ 共享内存段 --------------
键        shmid      拥有者  权限     字节     连接数  状态      
0x00000000 2          dominic    600        16384      1          目标       
0x00000000 753668     dominic    606        10089696   2          目标       
0x00000000 622597     dominic    600        4194304    2          目标       
0x00000000 753670     dominic    606        10089696   2          目标       
0x00000000 688135     dominic    600        899976     2          目标       
0x00000000 8          dominic    600        524288     2          目标       
0x00000000 9          dominic    600        524288     2          目标       
0x00000000 753674     dominic    600        7127040    2          目标 
0x0000006f 720918     dominic    666        1024        0

我们发现最后一个键值为0x0000006f = 111的共享内存段，就是我们创建的共享内存段。 删除指定共享内存段：

 ipcrm -m 720918  
 或者 
 ipcrm -M 0x0000006f  

信号量和消息队列的操作，命令类似，只是参数不同。 查看命令：

ipcs [-m|-q|-s]

• -m 输出有关共享内存 (shared memory) 的信息
• -q 输出有关信息队列 (message queue) 的信息
• -s 输出有关“信号量”(semaphore) 的信息

删除命令

ipcrm [ -M key | -m id | -Q key | -q id | -S key | -s id ]

• -M用 shmkey 删除共享内存
• -m用 shmid 删除共享内存
• -Q用 msgkey 删除消息队列
• -q用 msgid 删除消息队列
• -S用 semkey 删除信号量
• -s用 semid 删除信号量

超过共享内存的大小限制

共享内存的总体大小是有限制的，这个大小通过 SHMMAX 参数来定义（以字节为单位），您可以通过执行以下命令来确定 SHMMAX 的值：

cat /proc/sys/kernel/shmmax

如果机器上创建的共享内存的总共大小超出了这个限制，在程序中使用标准错误perror可能会出现以下的信息：

unable to attach to shared memory

1、设置 SHMMAX

　　SHMMAX 的默认值是 32MB 。一般使用下列方法之一种将 SHMMAX 参数设为 2GB ： 通过直接更改 /proc 文件系统，你不需重新启动机器就可以改变 SHMMAX 的默认设置。我使用的方法是将以下命令放入 />etc/rc.local 启动文件中：

echo "2147483648" > /proc/sys/kernel/shmmax

您还可以使用 sysctl 命令来更改 SHMMAX 的值：

sysctl -w kernel.shmmax=2147483648

最后，通过将该内核参数插入到/etc/sysctl.conf 启动文件中，您可以使这种更改永久有效：

echo "kernel.shmmax=2147483648" >> /etc/sysctl.conf

2、设置 SHMMNI

我们现在来看 SHMMNI 参数。这个内核参数用于设置系统范围内共享内存段的最大数量。该参数的默认值是 4096 。这一数值已经足够，通常不需要更改。您可以通过执行以下命令来确定 SHMMNI 的值：

cat /proc/sys/kernel/shmmni

3、设置 SHMALL

最后，我们来看 SHMALL 共享内存内核参数。该参数控制着系统一次可以使用的共享内存总量（以页为单位）。简言之，该参数的值始终应该至少为：ceil(SHMMAX/PAGE_SIZE)

SHMALL 的默认大小为 2097152 ，可以使用以下命令进行查询：

cat /proc/sys/kernel/shmall

　　SHMALL 的默认设置对于我们来说应该足够使用。注意：在 i386 平台上 Red Hat Linux 的 页面大小 为 4096 字节。但是，您可以使用 bigpages ，它支持配置更大的内存页面尺寸。

多次进行 shmat 操作会出现什么问题

一个进程是可以对同一个共享内存多次 shmat 进行挂载的，物理内存是指向同一块，如果 shmaddr 为 NULL，则每次返回的线性地址空间都不同。而且指向这块共享内存的引用计数会增加。也就是进程多块线性空间会指向同一块物理地址。这样，如果之前挂载过这块共享内存的进程的线性地址没有被shmdt掉，即申请的线性地址都没有释放，就会一直消耗进程的虚拟内存空间，很有可能会最后导致进程线性空间被使用完而导致下次 shmat 或者其他操作失败。

shmget 创建共享内存，当 key 相同时，什么情况下会出错？

当创建一个新的共享内存区时，size 的值必须大于 0；如果是访问一个已经存在的内存共享区，则置 size 为 0。

已经创建的共享内存的大小是可以调整的，但是已经创建的共享内存的大小只能调小，不能调大

当多个进程都能创建共享内存的时候，如果 key 出现相同的情况，并且一个进程需要创建的共享内存的大小要比另外一个进程要创建的共享内存小，共享内存大的进程先创建共享内存，共享内存小的进程后创建共享内存，小共享内存的进程就会获取到大的共享内存进程的共享内存，并修改其共享内存的大小和内容，从而可能导致大的共享内存进程崩溃。

ftok 是否一定会产生唯一的 key 值？

ftok 原型如下：

key_t ftok(char * pathname, int proj_id)

pathname就时你指定的文件名，proj_id是子序号。在一般的 UNIX 实现中，是将文件的索引节点号取出，前面加上子序号得到key_t的返回值。如指定文件的索引节点号为 65538，换算成 16 进制为0×010002，而你指定的proj_id值为38，换算成 16 进制为0×26，则最后的key_t返回值为0×26010002。