共享内存和信号量（灯）结合

共享内存：

是被多个进程共享的一部分物理内存.共享内存是进程间共享数据的一种最快的方法，一个进程向共享内存区域写入了数据，共享这个内存区域的所有进程就可以立刻看到其中的内容.

创建共享内存，使用shmget

int shmget ( key_t key, int size, int shmflg )

key标识共享内存的键值: 0/IPC_PRIVATE。 当key的取值为IPC_PRIVATE，则函数shmget()将创建一块新的共享内存；如果key的取值为0，而参数shmflg中又设置IPC_PRIVATE这个标志，则同样会创建一块新的共享内存。

返回值：如果成功，返回共享内存标识符；如果失败，返回-1

映射共享内存，将这段创建的共享内存映射到具体的进程空间去，使用shmat

char * shmat ( int shmid, char *shmaddr, int flag)

参数：
shmid：shmget函数返回的共享存储标识符
flag：决定以什么方式来确定映射的地址（通常为0）
返回值：
如果成功，则返回共享内存映射到进程中的地址；如果失败，则返回- 1

脱离映射，当一个进程不再需要共享内存时，需要把它从进程地址空间中脱离。
 int shmdt ( char *shmaddr )

信号量(又名：信号灯)与其他进程间通信方式不大相同，主要用途是保护临界资源.

进程可以根据它判定是否能够访问某些共享资源。除了用于访问控制外，还可用于进程同步

二值信号灯：信号灯的值只能取0或1，类似于互斥锁。 但两者有不同：

信号灯强调共享资源，只要共享资源可用，其他进程同样可以修改信号灯的值；

互斥锁更强调进程，占用资源的进程使用完资源后，必须由进程本身来解锁。

计数信号灯：信号灯的值可以取任意非负值

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

#define SHMKEY   1234
#define SHMSIZE  4096
#define SEMKEY   1234

union semun {
	int              val;    /* Value for SETVAL */
	struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
	unsigned short  *array;  /* Array for GETALL, SETALL */
	struct seminfo  *__buf;  /* Buffer for IPC_INFO(Linux specific) */
};

int sem_p(int id)
{
	struct sembuf buf;
	int ret;

	buf.sem_num = 0;                          //（信号量集）对第一个信号量进行semop操作
	buf.sem_op = -1;						  //进行减一操作
	buf.sem_flg = SEM_UNDO;                   //防止进程异常退出没有释放信号量

	ret = semop(id, &buf, 1);                 //只有一个信号量，只需要操作一次
	if (-1 == ret)
	{
		perror("semop");
		return 1;
	}
	
	return 0;
}

int sem_v(int id)
{
	struct sembuf buf;
	int ret;

	buf.sem_num = 0;
	buf.sem_op = 1;
	buf.sem_flg = SEM_UNDO;

	ret = semop(id, &buf, 1);
	if (-1 == ret)
	{
		perror("semop");
		return 1;
	}
	
	return 0;
	
}

int main()
{	
	int shmid, ret, semid;
	void *shmaddr;
	int count = 0, tmp;
	union semun union_sem;

	shmid = shmget(SHMKEY, SHMSIZE, IPC_CREAT | IPC_EXCL);    //创建共享内存 需要指定key以及内存大小
	if (-1 == shmid)
	{
		perror("shmget");
		exit(1);
	}

	shmaddr = shmat(shmid, NULL, 0);                          //映射 物理内存映射到虚拟内存
	if ((void *)-1 == shmaddr)
	{
		perror("shmat");
		exit(1);
	}

	semid = semget(SEMKEY, 1, IPC_CREAT | IPC_EXCL);          //创建信号量（集），只需要1个信号量
	if (-1 == semid)
	{
		perror("semget");
		exit(1);
	}

	union_sem.val = 1;                                        //联合体，用于初始化信号量 
	ret = semctl(semid, 0, SETVAL, union_sem);                //初始化信号量 初始化为1
	if (-1 == ret)
	{
		perror("semctl");
		exit(1);
	}

	*(int *)shmaddr = count;
	
	while(1)
	{
		sem_p(semid);                                        //p操作，对信号量减一
		tmp = *(int *)shmaddr;
		if (tmp > 1000)
		{
			break;
		}
		printf("Process 1 : count = %d\n", tmp);
		usleep(10);
		tmp++;
		*(int *)shmaddr = tmp;
		sem_v(semid);                                      //V操作，对信号量加一
	}
	ret = shmdt(shmaddr);                                 //解除映射（共享内存）
	if (-1 == ret)
	{
		perror("shmdt");
		exit(1);
	}

	usleep(1000);
	shmctl(shmid, IPC_RMID, NULL);                        //删除共享内存
	semctl(semid, 0, IPC_RMID);                           //删除信号量

	return 0;
}

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

#define SHMKEY   1234
#define SHMSIZE  4096
#define SEMKEY   1234

union semun {
	int              val;    /* Value for SETVAL */
	struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
	unsigned short  *array;  /* Array for GETALL, SETALL */
	struct seminfo  *__buf;  /* Buffer for IPC_INFO(Linux specific) */
};

int sem_p(int id)
{
	struct sembuf buf;
	int ret;

	buf.sem_num = 0;
	buf.sem_op = -1;
	buf.sem_flg = SEM_UNDO;

	ret = semop(id, &buf, 1);
	if (-1 == ret)
	{
		perror("semop");
		return 1;
	}
	
	return 0;
}

int sem_v(int id)
{
	struct sembuf buf;
	int ret;

	buf.sem_num = 0;
	buf.sem_op = 1;
	buf.sem_flg = SEM_UNDO;

	ret = semop(id, &buf, 1);
	if (-1 == ret)
	{
		perror("semop");
		return 1;
	}
	
	return 0;
	
}

int main()
{	
	int shmid, ret, semid;
	void *shmaddr;
	int count = 0, tmp;
	union semun union_sem;

	shmid = shmget(SHMKEY, SHMSIZE, 0);    //创建共享内存
	if (-1 == shmid)
	{
		perror("shmget");
		exit(1);
	}

	shmaddr = shmat(shmid, NULL, 0);                          //映射
	if ((void *)-1 == shmaddr)
	{
		perror("shmat");
		exit(1);
	}

	semid = semget(SEMKEY, 1, 0);          //创建信号量
	if (-1 == semid)
	{
		perror("semget");
		exit(1);
	}

	/*union_sem.val = 1;
	ret = semctl(semid, 0, SETVAL, union_sem);
	if (-1 == ret)
	{
		perror("semctl");
		exit(1);
	}*/

	while(1)
	{
		sem_p(semid);
		tmp = *(int *)shmaddr;
		if (tmp > 1000)
		{
			break;
		}
		printf("Process 2 : count = %d\n", tmp);
		usleep(10);
		tmp++;
		*(int *)shmaddr = tmp;
		sem_v(semid);
	}
	ret = shmdt(shmaddr);
	if (-1 == ret)
	{
		perror("shmdt");
		exit(1);
	}

	return 0;
}

信号灯强调共享资源，只要共享资源可用，其他进程同样可以修改信号灯的值；

互斥锁更强调进程，占用资源的进程使用完资源后，必须由进程本身来解锁。

计数信号灯：信号灯的值可以取任意非负值