进程通信 信号量

控制的机制，其实为了解决互斥共享资源的同步问题而引入的机制。
不能单独定义一个信号量，而只能定义一个信号量集，其中包括一组信号量，同意信号量集中的信号量使用同
一引用ID，这样设置是为了多个资源或同步操作的需要。
与信号量有关的几个系统调用函数：
1、信号量集得创建与打开 semget()
原型：int semget(key_t key,int nsems,int semflg);
其中 参数key表示所创建或打开信号量集的键。
    参数nsems表示创建的信号量集中的信号量的个数，该参数只在创建信号量集时有效。
    参数flag表示调用函数的操作类型，也可用于设置信号量集的访问权限，两者通过or表示。
当调用semget创建一个信号量时，他的相应的semid_ds结构被初始化。ipc_perm中各个量被设置为相应
值，sem_nsems被设置为nsems所示的值，sem_otime被设置为0，sem_ctime被设置为当前时间
返回值：如果成功，则返回信号量集的IPC标识符。如果失败，则返回-1：errno=EACCESS(没有权限)
EEXIST(信号量集已经存在，无法创建)
EIDRM(信号量集已经删除)
ENOENT(信号量集不存在，同时没有使用IPC_CREAT)
ENOMEM(没有足够的内存创建新的信号量集)
ENOSPC(超出限制)
系统调用semget()的第一个参数是关键字值（一般是由系统调用ftok()返回的）。系统内核将此值和系统中
存在的其他的信号量集的关键字值进行比
较。打开和存取操作与参数semflg中的内容相关。IPC_CREAT如果
信号量集在系统内核中不存在，则创建信号量集。IPC_EXCL当和
IPC_CREAT一同使用时，如果信号量集已经
存在，则调用失败。如果单独使用IPC_CREAT，则semget()要么返回新创建的信号量集的标识
符，要么返回
系统中已经存在的同样的关键字值的信号量的标识符。如果IPC_EXCL和IPC_CREAT一同使用，则要么返回新
创建的信号量集的标识
符，要么返回-1。IPC_EXCL单独使用没有意义。参数nsems指出了一个新的信号量集
中应该创建的信号量的个数。
2、信号量的操作 semop()
调用原型：int semop(int semid,struct sembuf*sops,unsign ednsops);
其中  semid为信号量集引用ID。
     semoparray是一个sembuff结构数组，sembuff结构用于指定调用semop函数所作的操作，数组
     semoparray元素的个数有参数nops指出。
     semoparray是一个数组，其中每个元素表是一个操作，由于此函数是一个原子操作，一旦执行就
将执行数组中的所有操作。
返回值：0，如果成功。-1，如果失败：errno=E2BIG(nsops大于最大的ops数目)
EACCESS(权限不够)
EAGAIN(使用了IPC_NOWAIT，但操作不能继续进行)
EFAULT(sops指向的地址无效)
EIDRM(信号量集已经删除)
EINTR(当睡眠时接收到其他信号)
EINVAL(信号量集不存在,或者semid无效)
ENOMEM(使用了SEM_UNDO,但无足够的内存创建所需的数据结构)
ERANGE(信号量值超出范围)
如果sem_op是负数，那么信号量将减去它的值。这和信号量控制的资源有关。如果没有使用IPC_NOWAIT，
那么调用进程将进入睡眠状态，直到信号
量控制的资源可以使用为止。如果sem_op是正数，则信号量加上
它的值。这也就是进程释放信号量控制的资源。最后，如果sem_op是0，那么调用进程
将调用sleep()，
直到信号量的值为0。这在一个进程等待完全空闲的资源时使用。
3、信号量的控制 semctl()
原型：int semctl(int semid,int semnum,int cmd,union semun arg);
其中  semid为信号量集引用标志符。
     semnum用于指定某个特定信号量。
     cmd表示调用该函数执行的操作，其取值和对应操作如下：
         .IPC_STAT读取一个信号量集的数据结构semid_ds，并将其存储在semun中的buf参数中。
         ·IPC_SET设置信号量集的数据结构semid_ds中的元素ipc_perm，其值取自semun中的buf参数。
         ·IPC_RMID将信号量集从内存中删除。
         ·GETALL用于读取信号量集中的所有信号量的值。
         ·GETNCNT返回正在等待资源的进程数目。
         ·GETPID返回最后一个执行semop操作的进程的PID。
         ·GETVAL返回信号量集中的一个单个的信号量的值。
         ·GETZCNT返回这在等待完全空闲的资源的进程数目。
         ·SETALL设置信号量集中的所有的信号量的值。
         ·SETVAL设置信号量集中的一个单独的信号量的值。
    arg是semnu的是一个联合类型的副本，而不是一个指向联合类型的指针。联合中各个量的使用情况
和参数cmd的设置有关。

本例示范Linux信号量的基本用法。该范例使用了两个线程分别对一个公用队列进行入队和出队操作，并用信号量进行控制，当队列空时出队操作可以被阻塞，当队列满时入队操作可以被阻塞。

主要用到的信号量函数有：
sem_init：初始化信号量sem_t，初始化的时候可以指定信号量的初始值，以及是否可以在多进程间共享。
sem_wait：一直阻塞等待直到信号量>0。
sem_timedwait：阻塞等待若干时间直到信号量>0。
sem_post：使信号量加1。
sem_destroy：释放信号量。和sem_init对应。
关于各函数的具体参数请用man查看。如man sem_init可查看该函数的帮助。

下面看具体的代码：

// --------------------------msgdequeue.h开始-------------------------------------
// 实现可控队列
#ifndef MSGDEQUEUE_H
#define  MSGDEQUEUE_H
#include  " tmutex.h "
#include  < iostream >
#include  < errno.h >
#include  < time.h >
#include  < semaphore.h >
#include  < deque >
using   namespace  std;

template < typename T,typename MUTEX_TYPE  =  ThreadMutex >
class  CMessageDequeue
... {
public :
        CMessageDequeue(size_t MaxSize) : m_MaxSize( MaxSize )
         ... {
                sem_init(  & m_enques, 0 , m_MaxSize );  // 入队信号量初始化为MaxSize，最多可容纳MaxSize各元素
                sem_init(  & m_deques, 0 , 0  );  // 队列刚开始为空，出队信号量初始为0
        }

         ~ CMessageDequeue()
         ... {
                sem_destroy( & m_enques);
                sem_destroy( & m_deques);
        }

         int  sem_wait_i( sem_t  * psem,  int  mswait )
         ... { // 等待信号量变成>0，mswait为等待时间，若mswait<0则无穷等待，否则等待若干mswait毫秒。
                 if ( mswait  <   0  )
                 ... {
                         int  rv  =   0 ;                          
                         while ( ((rv  =  sem_wait(psem) )  !=   0  )  &&  (errno  ==  EINTR
) );     // 等待信号量，errno==EINTR屏蔽其他信号事件引起的等待中断
                         return  rv;    
                }                                             
                 else                                          
                 ... {                                            
                        timespec ts;                         
                        clock_gettime(CLOCK_REALTIME,  & ts );     // 获取当前时间
                        ts.tv_sec  +=  (mswait  /   1000  );         // 加上等待时间的秒数
                        ts.tv_nsec  +=  ( mswait  %   1000  )  *   1000 ;  // 加上等待时间纳秒数
                         int  rv  =   0 ;                          
                         while ( ((rv = sem_timedwait( psem,  & ts )) != 0 )  &&  (errno  ==
EINTR) );    // 等待信号量，errno==EINTR屏蔽其他信号事件引起的等待中断
                         return  rv;   
                }                                             
                                                             
        }                                                     
         bool  push_back(  const  T  & item,  int  mswait  =   - 1  )     
         ... {  // 等待mswait毫秒直到将item插入队列，mswait为-1则一直等待                                                   
                 if (  - 1   ==  sem_wait_i(  & m_enques, mswait ))   
                 ... {                                            
                         return   false ;                        
                }

                   // AUTO_GUARD：定界加锁，见Linux多线程及临界区编程例解的tmutex.h文件定义。                             
                AUTO_GUARD( g, MUTEX_TYPE, m_lock );
                 try                                           
                 ... {                                            
                        m_data.push_back( item );            
                        cout  <<   " push  "   <<  item  <<  endl;     
                        sem_post(  & m_deques );               
                         return   true ;                         
                }                                             
                 catch (...)                                   
                 ... {                                            
                         return   false ;                        
                }                                             
        }         

       bool  pop_front( T  & item,  bool  bpop  =   true ,  int  mswait  =   - 1  )      
         ... {  // 等待mswait毫秒直到从队列取出元素，mswait为-1则一直等待                                                     
                 if (  - 1   ==  sem_wait_i(  & m_deques, mswait ) )  
                 ... {                                            
                         return   false ;                        
                }            
                  // AUTO_GUARD：定界加锁，见Linux多线程及临界区编程例解的tmutex.h文件定义。                   
                AUTO_GUARD( g, MUTEX_TYPE, m_lock );         
                 try                                           
                 ... {                                            
                        item  =  m_data.front();               
                         if ( bpop )                           
                         ... {                                    
                                m_data.pop_front();          
                                cout  <<   " pop  "   <<  item  <<  endl;
                        }                                     
                                                             
                        sem_post(  & m_enques );               
                         return   true ;                         
                }                                             
                 catch (...)                                   
                 ... {                                            
                         return   false ;                        
                }                                             
        }                                                     
        inline size_t size()                                 
         ... {                                                    
                 return  m_data.size();                        
        }      

private :                                                     
        MUTEX_TYPE m_lock;                                   
        deque < T >  m_data;                                     
        size_t m_MaxSize;                                    
        sem_t m_enques;                                      
        sem_t m_deques;                                      
} ;                                                           
                                                             
#endif                          

// --------------------------msgdequeue.h结束-------------------------------------

// --------------------------test.cpp开始-------------------------------------
// 主程序文件

#include  " msgdequeue.h "
#include  < pthread.h >
#include  < iostream >
using   namespace  std;

CMessageDequeue < int >  qq( 5 );

void   * get_thread( void   * parg);
void   * put_thread( void   * parg);

void   * get_thread( void   * parg)
... {
         while ( true )
         ... {
                 int  a  =   - 1 ;
                 if (  ! qq.pop_front( a, true ,  1000  ) )
                 ... {
                        cout  <<   " pop failed. size= "   <<  qq.size()  <<  endl;
                }
        }
         return  NULL;
}

void   * put_thread( void   * parg)
... {
         for ( int  i = 1 ; i <= 30 ; i ++ )
         ... {
                qq.push_back( i,  - 1  );
        }

         return  NULL;                                         
}                                                             
                                                             
int  main()                                                   
... {                                                          
        pthread_t pget,pput;                                 
        pthread_create(  & pget,NULL,get_thread,NULL);         
        pthread_create(  & pput, NULL, put_thread,NULL);       
                                                             
        pthread_join( pget,NULL );                           
        pthread_join( pput,NULL );                           
                                                             
         return   0 ;                                            
}       

// --------------------------test.cpp结束-------------------------------------

    编译程序：g++ msgdequeue.h test.cpp -lpthread -lrt -o test
    -lpthread链接pthread库。-ltr链接clock_gettime函数相关库。

    编译后生成可执行文件test。输入./test执行程序。

    线程get_thread每隔1000毫秒从队列取元素，线程put_thread将30个元素依次入队。两个线程模拟两条入队和出队的流水线。因我们在 CMessageDequeue<int> qq(5)处定义了队列最多可容纳5个元素，入队线程每入队到队列元素满5个后需阻塞等待出队线程将队列元素出队才能继续。测试时可调整队列可容纳最大元 素个数来观察运行效果。