一，C++ 常用进程间通信

• 管道(Pipe)：管道可用于具有亲缘关系进程间的通信，允许一个进程和另一个与它有共同祖先的进程之间进行通信。
• 命名管道(named pipe)：命名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。命名管道在文件系统中有对应的文件名。命名管道通过命令mkfifo或系统调用mkfifo来创建。
• 信号(Signal)：信号是比较复杂的通信方式，用于通知接受进程有某种事件发生，除了用于进程间通信外，进程还可以发送信号给进程本身;Linux除了支持Unix早期信号语义函数sigal外，还支持语义符合Posix.1标准的信号函数sigaction(实际上，该函数是基于BSD的，BSD为了实现可靠信号机制，又能够统一对外接口，用sigaction函数重新实现了signal函数)。
• 消息(Message)队列：消息队列是消息的链接表，包括Posix消息队列system V消息队列。有足够权限的进程可以向队列中添加消息，被赋予读权限的进程则可以读走队列中的消息。消息队列克服了信号承载信息量少，管道只能承载无格式字节流以及缓冲区大小受限等缺
• 共享内存：使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。
• 信号量(semaphore)：主要作为进程间以及同一进程不同线程之间的同步手段。
• 套接字(Socket)：更为一般的进程间通信机制，可用于不同机器之间的进程间通信。起初是由Unix系统的BSD分支开发出来的，但现在一般可以移植到其它类Unix系统上：Linux和System V的变种都支持套接字。

二，共享内存

1. 共享内存是最快的一种 IPC，因为进程是直接对内存进行存取。

2. 因为多个进程可以同时操作，所以需要进行同步。

3. 信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问。

// boosttest.cpp : 定义控制台应用程序的入口点。      
           
     
         
           
           
          
           
             
       //      
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
             
       #include "stdafx.h"      
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
             
       #include 
     
             
           
     
         
           
           
          
           
             
       #include 
      
             
           
     
         
           
           
          
           
             
       #include 
       
              
           
     
         
           
           
          
           
             
       #include 
        
               
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
             
       using        
       namespace        
       std;      
           
     
         
           
           
          
           
             
       using        
       namespace boost::interprocess;      
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
             
       int main(int argc,char *argv[])      
           
     
         
           
           
          
           
      
              {      
           
     
         
           
           
          
           
      	       
       cout <<        
       "argc" << argc<
         
          (region.get_address());      
           
     
         
           
           
          
           
      		       
       for (       
       std::       
       size_t i =        
       0; i < region.get_size(); ++i) {      
           
     
         
           
           
          
           
      			       
       if (*mem++ !=        
       1)      
           
     
         
           
           
          
           
      				       
       return        
       1;      
           
     
         
           
           
          
           
      			       
       else      
           
     
         
           
           
          
           
      
              			{      
           
     
         
           
           
          
           
      				       
       printf(       
       "mem:%d   ", *mem);      
           
     
         
           
           
          
           
      
              			}      
           
     
         
           
           
          
           
      
              		}      
           
     
         
           
           
          
           
      
              	}      
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
      
              	system(       
       "pause");      
           
     
         
           
           
          
           
      	       
       return        
       0;      
           
     
         
           
           
          
           
      
              }
         
        
       
      
     

三，消息队列

1. 消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。

2. 消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。

3. 消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。

// boosttest.cpp : 定义控制台应用程序的入口点。      
           
     
         
           
           
          
           
             
       //      
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
             
       #include "stdafx.h"      
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
             
       #include 
     
             
           
     
         
           
           
          
           
             
       #include 
      
             
           
     
         
           
           
          
           
             
       #include 
       
              
           
     
         
           
           
          
           
             
       #include 
        
               
           
     
         
           
           
          
           
             
       #include 
         
                
           
     
         
           
           
          
           
             
       #include 
          
            using namespace std; using namespace boost::interprocess; int main(int argc,char *argv[]) { cout << "argc" << argc<
          
         
        
       
      
     

四，信号量

1. 信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。

2. 信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。

3. 每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。

4. 支持信号量组。

// boosttest.cpp : 定义控制台应用程序的入口点。      
           
     
         
           
           
          
           
             
       //      
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
             
       #include "stdafx.h"      
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
             
       // boosttest.cpp : 定义控制台应用程序的入口点。      
           
     
         
           
           
          
           
             
       //      
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
             
       #include "stdafx.h"      
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
             
       #include 
     
             
           
     
         
           
           
          
           
             
       #include 
      
             
           
     
         
           
           
          
           
             
       #include 
       
              
           
     
         
           
           
          
           
             
       #include 
        
               
           
     
         
           
           
          
           
             
       #include 
         
                
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
             
       using        
       namespace        
       std;      
           
     
         
           
           
          
           
             
       using        
       namespace boost::interprocess;      
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
             
       struct  shared_memory_buffer      
           
     
         
           
           
          
           
      
              {      
           
     
         
           
           
          
           
      	       
       enum { NumItems =        
       100};       
       //数组大小      
           
     
         
           
           
          
           
      
              	shared_memory_buffer():mutex(       
       1),nempty(NumItems),nstored(       
       0){}      
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
      
              		interprocess_semaphore mutex, nempty, nstored;       
       //匿名信号量      
           
     
         
           
           
          
           
      		       
       int items[NumItems];       
       //共享数组      
           
     
         
           
           
          
           
      
              };      
           
     
         
           
           
          
           
             
       int main(int argc, char *argv[])      
           
     
         
           
           
          
           
      
              {      
           
     
         
           
           
          
           
      	       
       //cout << "argc" << argc << argv[0];      
           
     
         
           
           
          
           
      	       
       if (argc ==        
       1) {       
       //父进程      
           
     
         
           
           
          
           
      		       
       //1 删除共享内存      
           
     
         
           
           
          
           
      		       
       struct  shm_remove      
           
     
         
           
           
          
           
      
              		{      
           
     
         
           
           
          
           
      
              			shm_remove() { shared_memory_object::remove(       
       "SharedMemory"); }      
           
     
         
           
           
          
           
      
              		}remover;      
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
      		       
       //2 创建共享内存段      
           
     
         
           
           
          
           
      		       
       shared_memory_object shm(create_only, "SharedMemory", read_write);      
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
      		       
       //3 设置共享内存大小      
           
     
         
           
           
          
           
      
              		shm.truncate(       
       sizeof(shared_memory_buffer));      
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
      		       
       //4 映射共享内存片段      
           
     
         
           
           
          
           
      		       
       mapped_region region(shm, read_write);      
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
      		       
       //5 写数据，数据满了会阻塞      
           
     
         
           
           
          
           
      		       
       void *addr = region.get_address();      
           
     
         
           
           
          
           
      
              		shared_memory_buffer *data =        
       new(addr)shared_memory_buffer;      
           
     
         
           
           
          
           
      		       
       const        
       int NumMsg =        
       100;      
           
     
         
           
           
          
           
      		       
       for (       
       int i =        
       0; i < NumMsg; ++i) {      
           
     
         
           
           
          
           
      
              			data->nempty.wait();      
           
     
         
           
           
          
           
      
              			data->mutex.wait();      
           
     
         
           
           
          
           
      
              			data->items[i%shared_memory_buffer::NumItems] = i;      
           
     
         
           
           
          
           
      
              			data->mutex.post();      
           
     
         
           
           
          
           
      
              			data->nstored.post();      
           
     
         
           
           
          
           
      
              		}      
           
     
         
           
           
          
           
      
              	}      
           
     
         
           
           
          
           
      	       
       else      
           
     
         
           
           
          
           
      
              	{      
           
     
         
           
           
          
           
      
              		struct shm_remove      
           
     
         
           
           
          
           
      
              		{      
           
     
         
           
           
          
           
      
              			~shm_remove() { shared_memory_object::remove(       
       "MySharedMemory"); }      
           
     
         
           
           
          
           
      
              		} remover;      
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
      		       
       //1 创建共享内存      
           
     
         
           
           
          
           
      		       
       shared_memory_object shm(open_only, "SharedMemory", read_write);      
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
      		       
       //2 映射共享内存      
           
     
         
           
           
          
           
      		       
       mapped_region region(shm, read_write);      
           
     
         
           
           
          
           
             
           
     
         
           
           
          
           
      		       
       //3 共享数据复制到自己的缓冲      
           
     
         
           
           
          
           
      		       
       void * addr = region.get_address();      
           
     
         
           
           
          
           
      
              		shared_memory_buffer* data =        
       static_cast
          
           (addr); const int NumMsg = 100; int extracted_data[NumMsg]; for ( int i = 0; i < NumMsg; ++i) { data->nstored.wait(); data->mutex.wait(); extracted_data[i] = data->items[i%shared_memory_buffer::NumItems]; printf( "data:%d ", data->items[i%shared_memory_buffer::NumItems]); data->mutex.post(); data->nempty.post(); } } system( "pause"); return 0; }
          
         
        
       
      
     

信号量与互斥锁的区别：

1，作用域

信号量: 进程间或线程间(linux仅线程间)

互斥锁: 线程间

2，上锁时

信号量: 只要信号量的value大于0，其他线程就可以wait成功，成功后信号量的value减一。若value值不大于0，则wait阻塞，直到post释放后value值加一

互斥锁: 只要被锁住，其他任何线程都不可以访问被保护的资源