一，信号量的概念：
信号量（semaphore）本质上是一个计数器，用于多进程对共享数据对象的读取，它和管道有所不同，它不以传送数据为主要目的，它主要是用来保护共享资源（信号量也属于临界资源），使得资源在一个时刻只有一个进程独享。 在信号量进行PV操作时都为原子操作（因为它需要保护临界资源）。
二，信号量的结构：
信号量的数据结构为一个值和一个指针，指针指向等待该信号量的下一个进程。 信号量的值与相应资源的使用情况有关: 当信号量的值大于0时，表示当前可用资源的数量 ；当它的值小于0时，其绝对值表示等待使用该资源的进程个数 。
三，信号量对应的操作：
信号量的值仅能由PV操作来改变。
P操作：
sem变量减1 （获得资源）
若sem>=0，则P操作返回，该线程程可以“通过”并继续执行。
若sem<0，则该线程被阻塞，进入操作系统的阻塞队列 。
V操作：
sem变量加1（释放资源）
若sem>0，则V操作返回，该线程继续执行。
若sem<=0，则从阻塞队列中唤醒一个阻塞在该信号量上的线程，然后再返回原线程（调用ν操作的线程）继续执行。
Linux多进程访问共享资源时，需要按下列步骤进行操作：
（1）检测控制这个资源的信号量的值。
（2）如果信号量是正数，就可以使用这个资源。进程将信号量的值"减1"，表示当前进程占用了一份资源。访问资源结束后再执行“加 1”操作
（3）如果信号量是0，那么进程进入睡眠状态，直到信号量的值重新大于0时被唤醒，转入第一步操作
四，信号量的分类：
信号量按照使用场景分为 ： 二值信号量和计数信号量：
- 二值信号量：指初始值为 1 的信号量，此类信号量只有 1 和 0 两个值，通常用来代替锁机制实现线程同步， 在一个时刻仅允许有一个资源持有者；
- 计数信号量：指初始值大于 1 的信号量，当进程中存在多个线程，但某公共资源允许同时访问的线程数量是有限的，它允许在一个时刻至多有count个资源持有者，这时就可以用计数信号量来限制同时访问资源的线程数量。
*临界资源在同一时刻只允许一个进程使用，此时的信号量是一个二值信号量，它只控制一个资源；另一种应用于处理多个共享资源（例如多台打印机的分配），信号量在其中起到记录空闲资源数目的作用，此时的信号量是计数信号量。
五，信号量的处理函数：
对应的头文件： #include <semaphore.h>
信号量的创建&获取
semget函数
int semget(key_t key, int nsems, int semflg);
--功能：用来创建和访问一个信号量集
--参数
key：信号集的key值
nsems：信号集中信号量的个数
semflg：由九个权限标志构成，他们的用法和创建文件时使用的mode模式标志是一样的
--返回值：成功返回一个非负整数，即该信号集的标识码，失败返回-，并且更新errno
初始化信号量：
int sem_init(sem_t *sem, int pshared, unsigned int value);
参数说明:
a. sem为指向未初始化信号量结构的一个指针
b. pshared参数表示这个信号量是在进程的线程之间共享，还是在进程之间共享。
如果pshared的值为0，那么这个信号量会在进程的线程之间共享，并且应该位于对所有线程都可见的某个地址
如果pshared非零，那么这个信号量将在进程之间共享，并且应该位于共享内存的某个区域，(因为fork创建的子进程会继承父进程的内存映射，所以它也可以获取信号量)。
任何可以访问共享内存区域的进程都可以使用sem_post、sem_wait等对这个信号量进行操作。
c. value指定信号量的初始值
功能:
初始化信号量
返回值:成功返回0，失败返回-1
销毁信号量：
int sem_destroy(sem_t *sem);
参数说明:
sem为通过sem_init(3)初始化的信号量
功能:
释放信号量
返回值:成功返回0，失败返回-1
给信号量“加1”：
int sem_post(sem_t *sem);
参数说明:
sem为通过sem_init初始化的信号量
功能:
sem_post函数的作用是给信号量的值加上一个“1”，它是一个“原子操作”－－－即同时对同一个信号量做加“1”操作的两个线程是不会冲突的；
信号量的值永远会正确地加一个“2”－－因为有两个线程试图改变它。
返回值:成功返回0，失败返回-1
给信号量“减1”：
int sem_wait(sem_t *sem);
参数说明:
sem为通过sem_init初始化的信号量
功能:
sem_wait函数也是一个原子操作，它的作用是从信号量的值减去一个“1”，但它永远会先等待该信号量为一个非零值才开始做减法。
也就是说，如果你对一个值为2的信号量调用sem_wait(),线程将会继续执行,信号量的值将减到1。如果对一个值为0的信号量调用sem_wait()，
这个函数就会地等待直到有其它线程增加了这个值使它不再是0为止。如果有两个线程都在sem_wait()中等待同一个信号量变成非零值，
那么当它被第三个线程增加 一个“1”时，等待线程中只有一个能够对信号量做减法并继续执行，另一个还将处于等待状态。
返回值:成功返回0，失败返回-1
注意： 给资源加锁的时候等价于信号量“减1”，释放锁的时候等价于信号量“加1”，所以是先执行sem_wait, 后执行sem_post
六，具体的编程练习：
信号量编程步骤：
1.定义信号量:sem_t
2.初始化信号量:sem_init(sem_t *);
3.加锁：sem_wait()
4.执行业务逻辑代码
5.解锁：sem_post
6.销毁信号量：sem_destroy
Demo 1:
#include <pthread.h>
#include <semaphore.h>
sem_t mutex;
void *my_thread(void *arg){
while(1){
sem_wait(&mutex);
//some process code
sem_post(&mutex);
}
}
int main(){
pthread_t thread_1, thread_2;
sem_init(&mutex, 0 ,1);
pthread_create(&thread_1, NULL, &my_thread, NULL);
pthread_create(&thread_2, NULL, &my_thread, NULL);
pthread_join(thread_1, NULL);
pthread_join(thread_2, NULL);
sem_destroy(&mutex);
}
Demo2:
用信号量解决消费者-生产者问题
#include <pthread.h>
#include <semaphore.h>
#include <stdlib.h>
#include <stdio.h>
#define MaxItems 5
#define BufferSize 5
sem_t empty;
sem_t full;
int in = 0;
int out = 0;
int buffer[BufferSize];
pthread_mutex_t mutex;
void *producer(void *pno)
{
int i;
int item;
for(i = 0; i < MaxItems; i++) {
item = rand();
sem_wait(&empty);
pthread_mutex_lock(&mutex);
buffer[in] = item;
printf("Producer %d: Insert Item %d at %d\n", *((int *)pno),buffer[in],in);
in = (in+1)%BufferSize;
pthread_mutex_unlock(&mutex);
sem_post(&full);
}
}
void *consumer(void *cno)
{
int i;
for(i = 0; i < MaxItems; i++) {
sem_wait(&full);
pthread_mutex_lock(&mutex);
int item = buffer[out];
printf("Consumer %d: Remove Item %d from %d\n",*((int *)cno),item, out);
out = (out+1)%BufferSize;
pthread_mutex_unlock(&mutex);
sem_post(&empty);
}
}
int main()
{
pthread_t pro[5],con[5];
pthread_mutex_init(&mutex, NULL);
sem_init(&empty,0,BufferSize);
sem_init(&full,0,0);
int i;
int a[5] = {1,2,3,4,5};
for(i = 0; i < 5; i++) {
pthread_create(&pro[i], NULL, (void *)producer, (void *)&a[i]);
}
for(i = 0; i < 5; i++) {
pthread_create(&con[i], NULL, (void *)consumer, (void *)&a[i]);
}
for(i = 0; i < 5; i++) {
pthread_join(pro[i], NULL);
}
for(i = 0; i < 5; i++) {
pthread_join(con[i], NULL);
}
pthread_mutex_destroy(&mutex);
sem_destroy(&empty);
sem_destroy(&full);
return 0;
}
编译方式：
gcc sem_test.c -lpthread -o sem_test
./sem_test
Demo3： 吸烟者问题
假设一个系统有三个抽烟者进程和一个供应者进程。每个抽烟者不停地卷烟并抽掉它，但是要卷起并抽掉一支烟，抽烟者需要有三种材料:烟草、纸和胶水。三个抽烟者中，第一个拥有烟草、第二个拥有纸、第三个拥有胶水。供应者进程无限地提供三种材料，供应者每次将两种材料放桌子上，拥有剩下那种材料的抽烟者卷一根烟并抽掉它，并给供应者进程一个信号告诉完成了，供应者就会放另外两种材料在桌上，这个过程一直重复(让三个抽烟者轮流地抽烟)
图片参考： CSKAOYAN.COM
根据题目我们知道，放在桌上的材料一共有三种组合方式
- 纸和胶水（offer1）会被一号吸烟者取走
- 烟草和胶水（offer2）会被二号吸烟者取走
- 烟草和纸（offer3）会被三号吸烟者取走
本题可以看作是存在一个生产者和多个消费者的问题，同时生产者所生产的物品并不相同
C语言伪代码：
semaphore offer1=0; //桌上组合一的数量
semaphore offer2=0; //桌上组合二的数量
semaphore offer3=0; //桌上组合三的数量
semaphore finish=0; //抽烟是否完成
int i=0; //用于实现三个吸烟者轮流吸烟
//供应者进程
provider(){
while(1){
if(i==0){
将组合一放桌上
V(offer1); //提醒一号吸烟者吸烟
}else if(i==1){
将组合二放桌上
V(offer2); //提醒二号吸烟者吸烟
}else{
将组合三放桌上
V(offer3); //提醒三号吸烟者吸烟
}
i=(i+1)%3; //实现让三个吸烟者轮流吸烟
P(finish); //等待吸烟者吸烟完成后继续放组合
}
}
//一号吸烟者进程
smoker1(){
while(1){
P(offer1); //等待组合一放到桌上
从桌上拿走组合一，吸烟
V(finish); //提醒供应者提供新组合
}
}
//二号吸烟者进程
smoker2(){
while(1){
P(offer2); //等待组合二放到桌上
从桌上拿走组合二，吸烟
V(finish); //提醒供应者提供新组合
}
}
//三号吸烟者进程
smoker3(){
while(1){
P(offer3); //等待组合三放到桌上
从桌上拿走组合三，吸烟
V(finish); //提醒供应者提供新组合
}
}
具体的代码实现：
#include <stdio.h>
#include <sys/types.h>
#include <semaphore.h>
int table_used = 1;
int generated_item[2];
int generated = 0;
char *item[] = {"tubaco", "paper", "matches"};
sem_t table;
//供应者进程
void *agent(void *arg)
{
int i,j,k=0;
while(1)
{
sleep(1);
sem_wait(&table);
if (table_used == 1)
{
i = k;
j = i + 1;
if (j == 3)
j = 0;
k = j;
//模拟三种不同的组合
//[0,1] --> 吸烟者2抽烟
//[1,2] --> 吸烟者0抽烟
//[2,0] --> 吸烟者1抽烟
generated_item[0] = i;
generated_item[1] = j;
printf("agent is produced %s,%s\n", item[i], item[j]);
generated = 1;
table_used = 0;
}
sem_post(&table);
}
}
void *smoker(int i)
{
while(1)
{
sleep(1);
sem_wait(&table);
if (table_used == 0)
{
if(generated && generated_item[0] != i && generated_item[1] != i)
{
printf("smoker%d completed his smoking\n", i);
//释放桌子的空间
table_used = 1;
generated = 0;
}
}
sem_post(&table);
}
}
main()
{
pthread_t smk_0, smk_1, smk_2, agent;
sem_init(&table,0,1);
pthread_create(&agent, 0, agent, 0);
pthread_create(&smk_0, 0, smoker, 0);
pthread_create(&smk_1, 0, smoker, 1);
pthread_create(&smk_2, 0, smoker, 2);
while(1);
}