信号量称为进化版的互斥锁。由于互斥锁的粒度比较大，如果我们希望在多个线程间对某一对象的部分数据进行共享，使用互斥锁是没有办法实现的，只能将整个数据对象锁住。这样虽然达到了多线程操作共享数据时保证数据正确性的目的，却无形中导致线程的并发性下降。线程从并行执行，变成了串行执行。与直接使用单进程无异。信号量，是相对折中的一种处理方式，既能保证同步，数据不混乱，又能提高线程并发。例如，有5台打印机被多个线程共同使用，如果使用互斥锁，则每次同时只能有一个打印机被一个线程使用，但是如果采用信号量，那么同时最多可有5个线程共同使用五台打印机，使得共享资源得到充分利用，程序并行性提高，效率更高。其实信号量初值为1时的情况就是互斥锁。信号量是互斥锁的加强版。

主要应用函数：

sem_init函数          sem_destroy函数            sem_wait函数

sem_trywait函数            sem_timedwait函数          sem_post函数

以上6 个函数的返回值都是：成功返回0，失败返回-1，同时设置errno。（注意，它们没有pthread前缀）  因为，信号量既可以用于线程间同步，也可以用于进程间同步，因此失败返回值为-1，同时置errno。

sem_t类型，本质仍是结构体。但应用期间可简单看作为整数，忽略实现细节（类似于使用文件描述符）。

sem_t sem;  规定信号量sem不能 < 0。 头文件 <semaphore.h>

（1）信号量基本操作

sem_wait: 信号量大于0，则信号量--（类比pthread_mutex_lock）；信号量等于0，造成线程阻塞

sem_post：将信号量++，同时唤醒阻塞在信号量上的线程（类比pthread_mutex_unlock）。

由于sem_t的实现对用户隐藏，所以所谓的++、--操作只能通过函数来实现，而不能直接++、--符号。信号量的初值，决定了占用信号量的线程的个数。

（2）sem_init函数

int sem_init(sem_t *sem, int pshared, unsigned int value);

作用：初始化一个信号量。参1：sem信号量；参2：pshared取0用于线程间；取非0（一般为1）用于进程间；参3：value指定信号量初值。

（3）sem_destroy函数

int sem_destroy(sem_t *sem);

作用：销毁一个信号量

（4）sem_wait函数

int sem_wait(sem_t *sem);

作用：给信号量加锁

（5）sem_post函数

int sem_post(sem_t *sem);   

作用：给信号量解锁 ++

（6）sem_trywait函数

int sem_trywait(sem_t *sem);      

作用：尝试对信号量加锁--（与sem_wait的区别类比lock和trylock）

（7）sem_timedwait函数

int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);

作用：限时尝试对信号量加锁。参2：abs_timeout采用的是绝对时间（同前面）。

总结：互斥量、信号量既可以用于进程间同步，也可以用于线程间同步（一般来说，进程间同步信号量用的多一点）；条件变量需要结合互斥量使用；读写锁用于线程间同步，而文件锁用于进程间同步。

（8）生产者消费者信号量模型

使用信号量完成线程间同步，模拟生产者，消费者问题。             

分析：如果仓库中装满了产品，生产者不能生产，只能阻塞；仓库中没有产品，消费者不能消费，只能等待数据。

//两个消费者，一个生产者的情况

#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <stdio.h>
#include <semaphore.h>
#include <string.h>


#define NUM 10    //仓库空间容量为10

int prdc[NUM] = {0};   //0值代表该位置为闲置（空）
sem_t sem_blank;   //定义一个信号量表示闲置的空间
sem_t sem_prdc;   //定义一个信号量表示产品的数量
int j=0;       //两个消费者都需要消耗产品，因此定义全局变量j，两消费者互斥访问

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;  //互斥锁 用于互斥访问j


void *productor( void *arg )   //生产者
{
        srand( time( NULL ) );
        int i = 0;

        while(1) {
            sem_wait( &sem_blank );
            prdc[i] = (rand( )%400+1);
            printf("++++++++The production is %d.\n", prdc[i]);
            sem_post( &sem_prdc );  //对全局变量的操作必须位于wait与post之间
            i=( (i+1)%NUM );

            sleep( rand( )%3 );
        }

        return NULL;
}

void *consumer( void *arg )
{
        int s = (int)arg;
        srand( time( NULL ) );

        while(1) {
            sem_wait( &sem_prdc );
            pthread_mutex_lock( &mutex );  //互斥访问j
            printf("I am the %dth consumer, and I consumed the product of %d.\n", s, prdc[j]);
            prdc[j] = 0;
            j =( (j+1)%NUM );
            pthread_mutex_unlock( &mutex );
            sem_post( &sem_blank );

            sleep( rand( )%3 );
        }

        return NULL;
}

int main( void )
{
        pthread_t pid, cid1, cid2;
        int ret;

        sem_init( &sem_blank, 0, NUM );
        sem_init( &sem_prdc, 0, 0 );

        ret = pthread_create( &pid, NULL, productor, NULL );
        if( ret != 0 )
        {
            fprintf( stderr, "pthread_create error1: %s.\n", strerror(ret) );
            exit(1);
        }
        ret = pthread_create( &cid1, NULL, consumer, (void *)1 );
        if( ret != 0 )
        {
            fprintf( stderr, "pthread_create error2: %s.\n", strerror(ret) );
            exit(1);
        }
        ret = pthread_create( &cid2, NULL, consumer, (void *)2 );
        if( ret != 0 )
        {
            fprintf( stderr, "pthread_create error3: %s.\n", strerror(ret) );
            exit(1);
        }

        pthread_join( pid, NULL );
        pthread_join( cid1, NULL );
        pthread_join( cid2, NULL );

        sem_destroy( &sem_blank );
        sem_destroy( &sem_prdc );
        pthread_mutex_destroy( &mutex);

        return 0;
}

[root@localhost 02_pthread_sync_test]# ./semaphore

++++++++The production is 331.

I am the 2th consumer, and I consumed the product of 331.

++++++++The production is 371.

I am the 1th consumer, and I consumed the product of 371.

++++++++The production is 213.

I am the 1th consumer, and I consumed the product of 213.

++++++++The production is 260.

I am the 2th consumer, and I consumed the product of 260.

++++++++The production is 296.

I am the 1th consumer, and I consumed the product of 296.

++++++++The production is 59.

++++++++The production is 118.

I am the 2th consumer, and I consumed the product of 59.

I am the 1th consumer, and I consumed the product of 118.

++++++++The production is 228.

I am the 1th consumer, and I consumed the product of 228.

++++++++The production is 27.

++++++++The production is 360.

++++++++The production is 190.

I am the 2th consumer, and I consumed the product of 27.

I am the 2th consumer, and I consumed the product of 360.

I am the 1th consumer, and I consumed the product of 190.

++++++++The production is 177.

++++++++The production is 211.

I am the 1th consumer, and I consumed the product of 177.

I am the 2th consumer, and I consumed the product of 211.

分析：

1. 注意一点：生产者从i=0开始生产，那么消费者必须从j=0位置开始消费，保证位置一一对应，如果不对应，从逻辑上就是错误的。即整个逻辑过程就是：生产者在队列头部加产品，消费者从队列尾部拿走产品，整个队列从逻辑上是一个循环队列。
2. 对j的访问要互斥访问；
3. 从结果可以看出，先生产出来的先被消费，符合逻辑。

练习：结合生产者消费者信号量模型，揣摩sem_timedwait函数作用。编程实现，一个线程读用户输入， 另一个线程打印“hello world”。如果用户无输入，则每隔5秒向屏幕打印一个“hello world”；如果用户有输入，立刻打印“hello world”到屏幕。    

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <semaphore.h>

#define N 1024

sem_t s;

void *tfn(void *arg)
{
        char buf[N];

        while (1) {
                read(STDIN_FILENO, buf, N);   //阻塞读
                printf( " %s", buf);
                sem_post(&s);
        }

        return NULL;
}

int main(void)
{
        pthread_t tid;
        struct timespec t = {0, 0};

        sem_init(&s, 0, 0);
        pthread_create(&tid, NULL, tfn, NULL);
        t.tv_sec = time(NULL) + 1;   //防止时间失效，使sem_timedwait参数无效
        t.tv_nsec = 0;

        while (1) {
                sem_timedwait(&s, &t);
                printf(" hello world\n");
                t.tv_sec = time(NULL) + 5;
                t.tv_nsec = 0;
        }

        pthread_join(tid, NULL);
        sem_destroy(&s);

        return 0;
}

分析：

理解read函数的作用。read系统调用从文件中读数据时，默认方式为阻塞读，即如果没有读取数据（没有遇到换行符（enter键或者结束符）），则会一直阻塞等待数据的到来。对于空文件，有结束符，因此read读取时直接返回结果，读取的字节数为0，结束符不会打印出来；对于从标准输入（键盘）读取数据时，只有按到了enter（换行符），则read才会读取到数据，而换行符会被打印出来。read函数阻塞的话，则信号量的值一直为0，则主控线程中每隔5s打印一次hello world；（此时sem_timedwait函数执行失败，返回-1，置errno）。一旦read读取了数据，则信号量加1，主控线程马上执行sem_timedwait(&s, &t);成功，返回0 ，且向屏幕打印一次hello world。

UCOS-Ⅲ：信号量

一、信号量基本概念

信号量（Semaphore）是一种实现任务间通信的机制，可以实现任务之间同步或临界资源的互斥访问 （临界资源指同一时刻只能有有限个访问），常用于协助一组相互竞争的任务来访问临界资源。运行机制可以理解为：信号量是一个正值，代表资源的可访问数目，当有任务访问时，这个数目减一，任务访问完成时，任务访问结束，释放他，让他加一，信号量为0时，其他任务则不能获取他，选择退出或者等待挂起，直到有信号量释放后，按照优先级来获取信号量，获取后就绪，其运行流程大概如下图：

UCOS中信号量是内核对象，通过数据类型OS_SEM 定义，OS_SEM 源于结构体os_sem，UCOS中-Ⅲ的信号量相关的代码都被放在OS_SEM.C 中，通过设置OS_CFG.H 中的OS_CFG_SEM_EN 为1 使能信号量

                                             /* ----------------------------- SEMAPHORES ---------------------------- */
#define OS_CFG_SEM_EN                   1u   //使能或禁用多值信号量
#define OS_CFG_SEM_DEL_EN               1u   //使能或禁用 OSSemDel() 函数 
#define OS_CFG_SEM_PEND_ABORT_EN        1u   //使能或禁用 OSSemPendAbort() 函数
#define OS_CFG_SEM_SET_EN               1u   //使能或禁用 OSSemSet() 函数

信号量的结构体如下：

struct  os_sem {                                            /* Semaphore                                              */
                                                            /* ------------------ GENERIC  MEMBERS ------------------ */
    OS_OBJ_TYPE          Type;                              /* Should be set to OS_OBJ_TYPE_SEM                       */
    CPU_CHAR            *NamePtr;                           /* Pointer to Semaphore Name (NUL terminated ASCII)       */
    OS_PEND_LIST         PendList;                          /* List of tasks waiting on semaphore                     */
                                                            /* ------------------ SPECIFIC MEMBERS ------------------ */
    OS_SEM_CTR           Ctr;
    CPU_TS               TS;
};

第一个变量是**“Type”域**：表明UCOS识别所定义的是一个信号量。其它的内核对象也有“Type”域作为结构体的第一个变量。如果函数要调用一个内核对象，UCOS会检测所调用的内核对象的数据类型是否对应。例如，如果需要传递一个消息队列OS_Q 给函数，但实际传递的是一个信号量OS_SEM，UCOS就会检测出这是一个无效的参数，并返回错误代号。

第二个指针指向内核对象的名字：每个内核对象都可以被赋予一个名字，名字有ASCII 字符串组成，但必须以空字符结尾。

第三个等待列表PendList：若有多个任务等待信号量，信号量就会将这些任务放入其挂起队列中。

第四个包含一个信号量计数值：信号量计数值可以定义为8 位，16 位，或32 位，取决于OS_TYPE.H 中的OS_SEM_CTR是如何被定义的，这个值用于判断信号量可用的资源数目**（此值的上限大于1为多值信号量，只为0或者1则为二值信号量，UCOS-Ⅲ没有对这两个多做区分，全看如何使用）**

第五个CPU_TS时间戳：信号量中包含了一个时间戳变量，存储了上一次信号量被提交时的时间戳。当信号量被提交时，CPU 的时间戳被读取并存在信号量的时间戳变量中，当OSSemPend()被调用时就能读取这个时间戳变量。

用户代码也不能直接访问信号量中的变量。必须通过UCOS-III 提供的API来进行访问！

二、调用API

UCOS中信号量的调用API有以下四个API，分别为创建、删除、获取、释放信号量

2.1 创建信号量函数OSSemCreate()

OSSemCreate()函数进行创建一个信号量，跟消息队列的创建差不多，我们知道，其实这里的“创建信号量”指的就是对内核对象（信号量）的一些初始化。

函数入口：

void  OSSemCreate (OS_SEM      *p_sem,  //多值信号量控制块指针
                   CPU_CHAR    *p_name, //多值信号量名称
                   OS_SEM_CTR   cnt,    //资源数目或事件是否发生标志
                   OS_ERR      *p_err)  //返回错误类型

介绍：

p_err返回错误标志，其具体的返回值对应的情景如下

使用实例：

//定义结构体
OS_SEM SemOfKey;          //标志KEY1是否被按下的多值信号量

//使用前调用API初始化
任务体
{
    /* 创建多值信号量 SemOfKey */
    OSSemCreate((OS_SEM      *)&SemOfKey,    //指向信号量变量的指针
                (CPU_CHAR    *)"SemOfKey",    //信号量的名字
                (OS_SEM_CTR   )5,             //表示现有资源数目
                (OS_ERR      *)&err);         //错误类型
}

2.2 信号量删除函数OSSemDel()

OSSemDel()用于删除一个信号量，信号量删除函数是根据信号量结构（信号量句柄）直接删除的，删除之后这个信号量的所有信息都会被系统清空，而且不能再次使用这个信号量了，但是需要注意的是，如果某个信号量没有被定义，那也是无法被删除的，如果有任务阻塞在该信号量上，那么尽量不要删除该信号量。使用之前首先要将OS_CFG_SEM_DEL_EN 这个宏置1，注意调用这个函数后，之前用信号量保护的资源将不再得到保护。

函数入口：

OS_OBJ_QTY  OSSemDel (OS_SEM  *p_sem,  //多值信号量指针
                      OS_OPT   opt,    //选项
                      OS_ERR  *p_err)  //返回错误类型

参数选项选择

错误类型

同时该函数有一个返回值，返回值的含义为：

删除信号量的时候，会将信号量等待列表上的任务脱离该信号量的等待列表。返回值表示的就是脱离等待列表的任务个数。

使用实例

OS_SEM SemOfKey;; //声明信号量

/* 删除信号量 sem*/
OSSemDel ((OS_SEM *)&SemOfKey, //指向信号量的指针
		  OS_OPT_DEL_NO_PEND,
		  (OS_ERR *)&err); //返回错误类型

2.3 信号量释放函数OSSemPost()

当信号量有值的时候，任务才能获取信号量，有两个方式使信号量有值，一个是在创建的时候进行初始化，将它可用的信号量个数设置一个初始值；如果该信号量用作二值信号量，那么我们在创建信号量的时候其初始值的范围是0~1，假如初始值为1个可用的信号量的话，被获取一次就变得无效了，那就需要我们释放信号量，uCOS 提供了信号量释放函数，每调用一次该函数就释放一个信号量。UCOS可以一直释放信号量，但如果用作二值信号量的话，一直释放信号量就达不到同步或者互斥访问的效果，虽然说uCOS 的信号量是允许一直释放的，但是，信号量的范围还需我们用户自己根据需求进行决定，当用作二值信号量的时候，必须确保其可用值在0~1 范围内；而用作计数信号量的话，其范围是由用户根据实际情况来决定的

函数入口：

OS_SEM_CTR  OSSemPost (OS_SEM  *p_sem,    //多值信号量控制块指针
                       OS_OPT   opt,      //选项
                       OS_ERR  *p_err)    //返回错误类型

选项列表：

错误值：

OS_ERR_SEM_OVF 信号量计数值已经达到最大范围了，这次提交会引起信号量计数值溢出。

返回值：

信号量计数值

使用实例：

OS_SEM SemOfKey; //标志KEY1 是否被按下的信号量

OSSemPost((OS_SEM *)&SemOfKey, 	  	//发布SemOfKey
		(OS_OPT )OS_OPT_POST_ALL,   //发布给所有等待任务
		(OS_ERR *)&err); 			//返回错误类型

2.4 信号量获取函数OSSemPend()

当任务获取了某个信号量的时候，该信号量的可用个数就减一，当它减到0 的时候，任务就无法再获取了，并且获取的任务会进入阻塞态（假如用户指定了阻塞超时时间的话）。如果某个信号量中当前拥有1 个可用的信号量的话，被获取一次就变得无效了，那么此时另外一个任务获取该信号量的时候，就会无法获取成功，该任务便会进入阻塞态，阻塞时间由用户指定。uCOS 支持系统中多个任务获取同一个信号量，假如信号量中已有多个任务在等待，那么这些任务会按照优先级顺序进行排列，如果信号量在释放的时候选择只释放给一个任务，那么在所有等待任务中最高优先级的任务优先获得信号量，而如果信号量在释放的时候选择释放给所有任务，则所有等待的任务都会获取到信号量

函数入口：

OS_SEM_CTR  OSSemPend (OS_SEM   *p_sem,   //多值信号量指针
                       OS_TICK   timeout, //等待超时时间
                       OS_OPT    opt,     //选项
                       CPU_TS   *p_ts,    //等到信号量时的时间戳
                       OS_ERR   *p_err)   //返回错误类型

参数：

功能选项：

错误类型：

返回值：

信号量计数值

使用实例：

ctr = OSSemPend ((OS_SEM   *)&SemOfKey,               //等待该信号量 SemOfKey
                 (OS_TICK   )0,                       //下面选择不等待，该参无效
                 (OS_OPT    )OS_OPT_PEND_NON_BLOCKING,//如果没信号量可用不等待
                 (CPU_TS   *)0,                       //不获取时间戳
                 (OS_ERR   *)&err);                   //返回错误类型

if(err == OS_ERR_NONE)
{
    //获取成功
}   

三、信号量BUG-优先级反转

优先级反转是实时系统中的一个常见问题，存在于基于优先级的抢占式内核中，优先级反转的原理如下：

下图有三个调度任务L、M、H，任务H 的优先级高于任务M，任务M 的优先级高于任务L

任务L最开始运行的时候获取信号量，之后任务H开始执行，抢占了任务L，在任务H运行的时候，刚好需要获取信号量，但此时信号量还在任务L的手里，于是任务H进入挂起队列，任务L继续运行，在任务L没有释放信号量的时候，任务M过来抢占L运行，在任务L释放信号量时，任务H才继续执行，若任务M 需要执行很长时间，则任务H 会被延迟很长时间才执行，这叫做优先级反转。

解决方法是临时提高任务L的优先级，这一内容我们下一节互斥量再分析

四、使用实例

功能：信号量管理停车位资源，按键2按下释放信号量，停车位+1，串口打印数目，按键1按下获取信号量，停车位-1，串口显示是否获取成功

启动任务创建信号量

		/* 创建多值信号量 SemOfKey */
    OSSemCreate((OS_SEM      *)&SemOfKey,    //指向信号量变量的指针
               (CPU_CHAR    *)"SemOfKey",    //信号量的名字
               (OS_SEM_CTR   )5,             //表示现有资源数目
               (OS_ERR      *)&err);         //错误类型

再创建两个任务

任务一主体：

/*
*********************************************************************************************************
*                                          KEY1 TASK
*********************************************************************************************************
*/
static  void  AppTaskKey1 ( void * p_arg )
{
	OS_ERR      err;
	OS_SEM_CTR  ctr;
	CPU_SR_ALLOC();  //使用到临界段（在关/开中断时）时必需该宏，该宏声明和定义一个局部变
									 //量，用于保存关中断前的 CPU 状态寄存器 SR（临界段关中断只需保存SR）
									//，开中断时将该值还原。	
	uint8_t ucKey1Press = 0;
	
	
	(void)p_arg;

					 
	while (DEF_TRUE) {                                                         //任务体
		if( Key_Scan ( macKEY1_GPIO_PORT, macKEY1_GPIO_PIN, 1, & ucKey1Press ) ) //如果KEY1被按下
		{
			ctr = OSSemPend ((OS_SEM   *)&SemOfKey,               //等待该信号量 SemOfKey
								       (OS_TICK   )0,                       //下面选择不等待，该参无效
								       (OS_OPT    )OS_OPT_PEND_NON_BLOCKING,//如果没信号量可用不等待
								       (CPU_TS   *)0,                       //不获取时间戳
								       (OS_ERR   *)&err);                   //返回错误类型
			
			OS_CRITICAL_ENTER();                                  //进入临界段
			
			if ( err == OS_ERR_NONE )                      
				printf ( "\r\nKEY1被按下：成功申请到停车位，剩下%d个停车位。\r\n", ctr );
			else if ( err == OS_ERR_PEND_WOULD_BLOCK )
				printf ( "\r\nKEY1被按下：不好意思，现在停车场已满，请等待！\r\n" );
			
			OS_CRITICAL_EXIT(); 

		}
		
		OSTimeDlyHMSM ( 0, 0, 0, 20, OS_OPT_TIME_DLY, & err );  //每20ms扫描一次
		
	}
	
}

任务二主体：

static  void  AppTaskKey2 ( void * p_arg )
{
	OS_ERR      err;
	OS_SEM_CTR  ctr;
	CPU_SR_ALLOC();  //使用到临界段（在关/开中断时）时必需该宏，该宏声明和定义一个局部变
									 //量，用于保存关中断前的 CPU 状态寄存器 SR（临界段关中断只需保存SR）
									 //，开中断时将该值还原。
	uint8_t ucKey2Press = 0;
	
	
	(void)p_arg;

					 
	while (DEF_TRUE) {                                                         //任务体
		if( Key_Scan ( macKEY2_GPIO_PORT, macKEY2_GPIO_PIN, 1, & ucKey2Press ) ) //如果KEY2被按下
		{
		  ctr = OSSemPost((OS_SEM  *)&SemOfKey,                                  //发布SemOfKey
							        (OS_OPT   )OS_OPT_POST_ALL,                            //发布给所有等待任务
							        (OS_ERR  *)&err);                                      //返回错误类型
      
			OS_CRITICAL_ENTER();                                                   //进入临界段
			
			printf ( "\r\nKEY2被按下：释放1个停车位，剩下%d个停车位。\r\n", ctr );
			
			OS_CRITICAL_EXIT();
			
		}
		
		OSTimeDlyHMSM ( 0, 0, 0, 20, OS_OPT_TIME_DLY, & err );                    //每20ms扫描一次
		
	}
	
}

串口现象：

一、信号量概念
信号量是用来解决进程/线程之间的同步互斥问题的一种通信机制，它表示代表某一类资源。

1.信号量的类型
a.无名信号量：无名信号量只能存在于内存中，要求使用信号量的进程必须能访问信号量所在的这一块内存，所以无名信号量只能应用在同一进程间的线程或者共享内存间的进程。
b.有名信号量：用于进程（线程）间同步互斥

1>有名信号量必须指定一个相关联的文件名称，名称通常是文件系统中的某个文件，无名信号量不需要指定
2>有名信号量既可以用于线程间的同步，也可以用于进程间的同步；无名信号量通过shared参数来决定
是进程间还是相关线程共享
3>有名信号量随内核时间持续,一个进程创建一个信号量，另外的进程也可以通过该信号量的外部名（创建信号使用的文件名称）
来访问它。进程结束后，信号量还存在，并且信号量的值也不会改动。
4>无名信号量的持续性却是不定的：如果无名信号量是由单个进程内的各个线程共享的，那么该信号量就是随进程持续的，当该进程终止时它也会消失。如果某个无名信号量是在不同进程间同步的，该信号量必须存放在共享内存区中，只要该共享内存区存在，该信号量就存在。

2.信号量的pv操作
p操作：对信号量减1，若结果大于等于0，则进程继续，否则执行p操作的进程被阻塞等待释放。
v操作：对信号量加1，若结果小于等于0，则唤醒队列中一个因为p操作而阻塞的进程。

3.信号量的三种操作
1>信号量初始化
初始某类资源到可用的值

#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);
参数1：sem，无名信号量
参数2：pshared,确定信号量是由进程间共享还是线程间共享，0-线程间，非0进程间
参数3：信号量的初始值

//有名信号量创建
#include <semaphore.h>
sem_t *sem_open(const char *name, int oflag);  
sem_t *sem_open(const char *name, int oflag,	
                       mode_t mode, unsigned int value);
//第一种函数是当使用已有的有名信号量时调用该函数，flag 参数设为 0
//调用第二种函数，flag 参数应设为 O_CREAT ，如果有名信号量不存在，则会创建一个新的，如果存在，则会被使用并且不会再初始化。
//mode 参数指定谁可以访问信号量，即权限组

2>p操作申请资源

#include <semaphore.h>
int sem_wait(sem_t *sem);
int sem_trywait(sem_t *sem);
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);

参数：sem_wait是以原子操作的方式给信号量的值减1，但它会等到信号量非0时才会开始减法操作，如果此时信号量为0会进入阻塞等待的状态，直到信号量的值使它不再为0
sem:信号量
返回值：0成功 -1并设置出错码

第二个函数作用与第一个相同，此函数不阻塞线程，如果 sem 小于 0，直接返回一个错误（错误设置为 EAGAIN ）。

第三个函数作用也与第一个相同，第二个参数表示阻塞时间，如果 sem 小于 0 ，则会阻塞，参数指定阻塞时间长度。
struct timespec {
               time_t tv_sec;     /*Seconds*/
               long   tv_nsec;   /*Nanoseconds [0 ...999999999]*/
           };

if (信号量的值 > 0) {
申请资源的任务继续；信号量值--；
} else {
	申请资源的任务阻塞
}

3>V操作释放资源

#include <semaphore.h>
int sem_post(sem_t *sem);

参数：sem 信号量
返回值： 0-成功 -1-失败并设置出错码


#include <semaphore.h>
int sem_close(sem_t *sem);
//如果进程没有调用该函数便退出了，内核会自动关闭任何打开的信号量。无论是调用该函数还是内核自动关闭，都不会改变释放之前的信号量值。

4>信号量销毁
无名信号量会随着进程的终结，自动销毁。在不终止进程的情况下，销毁信号量可以使用sem_destroy;(有名信号量，如果不释放，会一直存在)

#include <semaphore.h>
int sem_destroy(sem_t *sem);

参数：sem 信号值
返回值： 0-成功 -1并设置出错码

代码demon

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

#define TIME_OUT 2000

void *function1(void *arg);
void *function2(void *arg);
sem_t sem1,sem2;

int main()
{
	pthread_t tid1,tid2;
	int ret;
	ret = sem_init(&sem1,0,0);
	if( -1 == ret)
	{
		perror("sem_init");
	}

	ret = sem_init(&sem2,0,0);
	if( -1 == ret)
	{
		perror("sem_init");
	}

	ret = pthread_create(&tid1,NULL,function1,NULL);
	if( 0 != ret)
	{
		perror("pthread_create 1");
	}

	ret = pthread_create(&tid2,NULL,function2,NULL);
	if( 0 != ret)
	{
		perror("pthreat_create 2");
	}

	ret = pthread_join(tid1,NULL);
	if( 0 != ret)
	{
		perror("pthread_join1");
	}

	ret = pthread_join(tid2,NULL);
	if( 0 != ret)
	{
		perror("pthread_join2");
	}

	ret = sem_destroy(&sem1);
	if( -1 == ret )
	{
		perror("sem_destory");
	}

	ret = sem_destroy(&sem2);
	if( -1 == ret )
	{
		perror("sem_destory");
	}
	
	return 0;
}

void time_add_ms(struct timeval *time, uint ms)
{
		time->tv_usec += ms * 1000; // 微秒 = 毫秒 * 1000
		if(time->tv_usec >= 1000000) // 进位，1000 000 微秒 = 1 秒
		{
				time->tv_sec += time->tv_usec / 1000000;
				time->tv_usec %= 1000000;
		}
}


void *function1(void *arg)
{
	int i,ret;
	struct timespec timeout;
	struct timeval time;
	ret = sem_wait(&sem1); //p操作申请资源
	if( -1 == ret)
	{
		perror("sem_wait");
	}

	for(i = 1; i <=2; i++)
	{
		printf("sem1----ppppppppppppppppp----\n");
		sleep(1);
	}

	ret = sem_post(&sem2); //v操作
	if( -1 == ret )
	{
		perror("sem_post");
	}
	printf("sem2  -------vvvvvvvvvvvvvvvvvvv-------\n");
	
	gettimeofday(&time, NULL);
    time_add_ms(&time, TIME_OUT);
	timeout.tv_sec = time.tv_sec;
    timeout.tv_nsec = time.tv_usec * 1000;
	printf("===time——out %d\n",sem_timedwait(&sem1, &timeout));
	printf("sem1 time out -----ppppppppppppppppp----\n");
	
	return NULL;
}

void *function2(void *arg)
{
	int i,ret;
	
	for(i = 1; i <=2; i++)
	{
		printf("######ppppppppppppppppp######\n");
		sleep(1);
	}
	
	ret = sem_post(&sem1);//v操作释放资源
	if( -1 == ret )
	{
		perror("sem_post");
	}
	printf("sem2 ====vvvvvvvvvvvvvvvvvvv====\n");
	
	ret = sem_wait(&sem2); //p操作申请资源
	if( -1 == ret)
	{
		perror("sem_wait");
	}

	for(i = 1; i <=3; i++)
	{
		printf("sem2 ====ppppppppppppppppp====\n");
		sleep(1);
	}

	return NULL;
}

运行结果：