线程及 进程间的通信问题！ .

一个很好的编程随想的博客http://program-think.blogspot.com/2009/03/producer-consumer-pattern-0-overview.html

架构设计：生产者/消费者模式[0]：概述

 1、如何确定数据单元
2、队列缓冲区
3、环形缓冲区
4、双缓冲区

生产 消费

2010-06-01 10:13

 

#include <boost/thread/thread.hpp> #include <boost/thread/mutex.hpp> #include <boost/thread/condition_variable.hpp> #include <queue> template<typename T,size_t BUF_SIZE> class Buffer { public:        void put(T const& element)        {          boost::unique_lock<boost::mutex> lock(mQueue_);                          while(queue_.size() == BUF_SIZE) //Buffer is full.Waiting...            not_full.wait(lock);              queue_.push(element);          not_empty.notify_all();        }               T get()        {          boost::unique_lock<boost::mutex> lock(mQueue_);                 while(queue_.empty())            //Buffer is empty.Waiting...             not_empty.wait(lock);             T element = queue_.front();          queue_.pop();                not_full.notify_all();          return element;        }   private:       std::queue<T> queue_;       boost::mutex   mQueue_;       boost::condition_variable not_full;       boost::condition_variable not_empty;     }; Buffer<int,10> buf; void producer() { for(int n=0;n<100;++n) {     buf.put(n); } } void consumer() { for(int x=0;x<100;++x) {     int n=buf.get(); } } int main() { boost::thread thrd1(&producer); boost::thread thrd2(&consumer); thrd1.join(); thrd2.join(); }

 

论1：线程和 进程间的通信问题。

以前一直想找个机会总结一下进程和线程的通信机制，但由于技术和平台的局限性，一直没有找准切入点。由于马上要毕业了，对自己技术的总结和梳理的前提下写了本篇文章，如有错误之处，敬请拍砖和指教。

         操作系统的主要任务是管理计算机的软件、硬件资源。现代操作系统的主要特点是多用户和多任务，也就是程序的并行执行，windows如此linux也是如此。所以操作系统就借助于进程来管理计算机的软、硬件资源，支持多任务的并行执行。要并行执行就需要多进程、多线程。因此多进程和多线程间为了完成一定的任务，就需要进行一定的通信。而线程间通信又和进程间的通信不同。由于进程的数据空间相对独立而线程是共享数据空间的，彼此通信机制也很不同。

         线程间通信：由于多线程共享地址空间和数据空间，所以多个线程间的通信是一个线程的数据可以直接提供给其他线程使用，而不必通过操作系统（也就是内核的调度）。

         进程间的通信则不同，它的数据空间的独立性决定了它的通信相对比较复杂，需要通过操作系统。以前进程间的通信只能是单机版的，现在操作系统都继承了基于套接字（socket）的进程间的通信机制。这样进程间的通信就不局限于单台计算机了，实现了网络通信。

        进程的通信机制主要有：管道、有名管道、消息队列、信号量、共享空间、信号、套接字。

        管道：它传递数据是单向性的，只能从一方流向另一方，也就是一种半双工的通信方式；只用于有亲缘关系的进程间的通信，亲缘关系也就是父子进程或兄弟进程；没有名字并且大小受限，传输的是无格式的流，所以两进程通信时必须约定好数据通信的格式。管道它就像一个特殊的文件，但这个文件之存在于内存中，在创建管道时，系统为管道分配了一个页面作为数据缓冲区，进程对这个数据缓冲区进行读写，以此来完成通信。其中一个进程只能读一个只能写，所以叫半双工通信，为什么一个只能读一个只能写呢?因为写进程是在缓冲区的末尾写入，读进程是在缓冲区的头部读取，他们各自 的数据结构不同，所以功能不同。

        有名管道：看见这个名字就能知道个大概了，它于管道的不同的是它有名字了。这就不同与管道只能在具有亲缘关系的进程间通信了。它提供了一个路径名与之关联，有了自己的传输格式。有名管道和管道的不同之处还有一点是,有名管道是个设备文件，存储在文件系统中，没有亲缘关系的进程也可以访问，但是它要按照先进先出的原则读取数据。同样也是单双工的。

        消息队列：是存放在内核中的消息链表，每个消息队列由消息队列标识符标识，于管道不同的是，消息队列存放在内核中，只有在内核重启时才能删除一个消息队列，内核重启也就是系统重启，同样消息队列的大小也是受限制的。

        信号量：也可以说是一个计数器，常用来处理进程或线程同步的问题，特别是对临界资源的访问同步问题。临界资源：为某一时刻只能由一个进程或线程操作的资源，当信号量的值大于或等于0时，表示可以供并发进程访问的临界资源数，当小于0时，表示正在等待使用临界资源的进程数。更重要的是，信号量的值仅能由PV操作来改变。

        共享内存：就是分配一块能被其他进程访问的内存。共享内存可以说是最有用的进程间通信方式，也是最快的IPC形式。首先说下在使用共享内存区前，必须通过系统函数将其附加到进程的地址空间或说为映射到进程空间。两个不同进程A、B共享内存的意思是，同一块物理内存被映射到进程A、B各自的进程地址空间。进程A可以即时看到进程B对共享内存中数据的更新，反之亦然。由于多个进程共享同一块内存区域，必然需要某种同步机制，互斥锁和信号量都可以。采用共享内存通信的一个显而易见的好处是效率高，因为进程可以直接读写内存，而不需要任何数据的拷贝。对于像管道和消息队列等通信方式，则需要在内核和用户空间进行四次的数据拷贝，而共享内存则只拷贝两次数据[1]：一次从输入文件到共享内存区，另一次从共享内存区到输出文件。实际上，进程之间在共享内存时，并不总是读写少量数据后就解除映射，有新的通信时，再重新建立共享内存区域。而是保持共享区域，直到通信完毕为止，这样，数据内容一直保存在共享内存中，并没有写回文件。共享内存中的内容往往是在解除映射时才写回文件的。因此，采用共享内存的通信方式效率是非常高的。

         信号：信号是在软件层次上对中断机制的一种模拟，在原理上，一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。信号是异步的，一个进程不必通过任何操作来等待信号的到达，事实上，进程也不知道信号到底什么时候到达。信号是进程间通信机制中唯一的异步通信机制，可以看作是异步通知，通知接收信号的进程有哪些事情发生了。信号机制经过POSIX实时扩展后，功能更加强大，除了基本通知功能外，还可以传递附加信息。信号事件的发生有两个来源：硬件来源(比如我们按下了键盘或者其它硬件故障)；软件来源。信号分为可靠信号和不可靠信号，实时信号和非实时信号。进程有三种方式响应信号1.忽略信号2.捕捉信号 3.执行缺省操作。

        套接字：这一块在网络编程那一块讲的 很多，在此就不在说拉。

论2：VC 线程间通信

1.使用全局变量(窗体不适用)
     实现线程间通信的方法有很多，常用的主要是通过全局变量、自定义消息和事件对象等来实现
的。其中又以对全局变量的使用最为简洁。该方法将全局变量作为线程监视的对象，并通过在主线
程对此变量值的改变而实现对子线程的控制。
     由于这里的全局变量需要在使用它的线程之外对其值进行改变，这就需要通过volatile关键字对
此变量进行说明。对于标准类型的全局变量，我们建议使用volatile 修饰符，它告诉编译器无需对该变量作任何的优化，即无需将它放到一个寄存器中，并且该值可被外部改变。如果线程间所需传递的信息较复杂，我们可以定义一个结构，通过传递指向该结构的指针进行传递信息。
使用全局变量进行线程通信的方法非常简单，通过下面给出的示例代码能够对其
有一个基本的认识。
 
2.利用自定义消息(可适用于窗体)
     全局变量在线程通信中的应用多用在主线程对子线程的控制上，而从子线程向主线程的信息反馈
则多采用自定义消息的方式来进行。一个线程向另外一个线程发送消息是通过操作系统实现的。利用Windows操作系统的消息驱动机制，当一个线程发出一条消息时，操作系统首先接收到该消息，然后把该消息转发给目标线程，接收消息的线程必须已经建立了消息循环。这里对自定义消息的使用同使用普通自定义消息非常相似，只
不过消息的发送是在子线程函数中进行的。该方法的主体是自定义消息，应首先定义自定义消息并
添加对消息的响应代码。
      用PostMessage()或SendMessage()消息传递函数.
 
3.使用事件内核对象(相当好用)
     利用事件(Event)内核对象对线程的通信要复杂些，主要通过对事件对象的监视来实现线程间的
通信。事件对象由CreateEvent()函数来创建，具有两种存在状态：置位与复位，分别由SetEvent()
和ResetEvent()来产生。事件的置位将通过 WaitForSingleObject()或WaitForMultipleObjects()之类
的通知等待函数继续执行。
// 事件句柄
HANDLE hEvent = NULL;
UINT ThreadProc7(LPVOID pParam)
{
                 while(true)
                 {
                               // 等待事件发生
                               DWORD dwRet = WaitForSingleObject(hEvent, 0);
                               // 如果事件置位则退出线程,否则将继续执行
                               if (dwRet == WAIT_OBJECT_0)
                                            break;
                               else
                               {
                                            Sleep(2000);

                                            AfxMessageBox("线程正在运行!");
                               }
                 }
               
                 AfxMessageBox("线程终止运行!");
                 return 0;
}
……
void CSample06View::OnEventStart() 
{
                 // 创建事件   
                 hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
               
                 // 启动线程
                 AfxBeginThread(ThreadProc7, NULL);
}
void CSample06View::OnEventEnd() 
{
                 // 事件置位
                 SetEvent(hEvent);             
}
     上面这段代码展示了事件对象在线程通信中的作用。在创建线程前首先创建一个事件对象hEven
t,这里CreateEvent()函数所采用的四个参数分别表示句柄不能被继承、事件在置位后将由系统自动
进行复位、事件对象初始状态为复位状态和不指定事件名。在创建的子线程中使用 WaitForSingle
Object()对hEvent进行监视。WaitForSingleObject()的函数原型为：
                 DWORD WaitForSingleObject(
                               HANDLE hHandle,                             //等待对象的句柄
                               DWORD dwMilliseconds           //超过时间间隔
                 );
     函数将在hHandle对象有信号时或是在等待时间超出由dwMilliseconds设定的超时时间间隔返
回。其返回值可以为 WAIT_ABANDONED、WAIT_OBJECT_0和WAIT_TIMEOUT，分别表示被
等待的互斥量(Mutex)对象没有被释放、等待的对象信号置位和超时。通过对返回值的判断可以区分
出引起WaitForSingleObject()函数返回的原因。在本例中只关心 WAIT_OBJECT_0的返回值，当
通过SetEvent()将hEvent置位后即可使WaitForSingleObject()立即返回并通过跳出循环而结束线
程。

 

论3：线程之间的通信

　　通常情况下，一个次级线程要为主线程完成某种特定类型的任务，这就隐含着表示在主线程和次级线程之间需要建立一个通信的通道。一般情况下，有下面的几种方法实现这种通信任务：使用全局变量（上一节的例子其实使用的就是这种方法）、使用事件对象、使用消息。这里我们主要介绍后两种方法。

　　（一） 利用用户定义的消息通信

　　在Windows程序设计中，应用程序的每一个线程都拥有自己的消息队列，甚至工作线程也不例外，这样一来，就使得线程之间利用消息来传递信息就变的非常简单。首先用户要定义一个用户消息，如下所示：#define WM_USERMSG WMUSER+100；在需要的时候，在一个线程中调用：：PostMessage((HWND)param,WM_USERMSG,0,0)或CwinThread::PostThradMessage（）来向另外一个线程发送这个消息，上述函数的四个参数分别是消息将要发送到的目的窗口的句柄、要发送的消息标志符、消息的参数WPARAM和LPARAM。下面的代码是对上节代码的修改，修改后的结果是在线程结束时显示一个对话框，提示线程结束：

UINT ThreadFunction(LPVOID pParam)
{
　while(!bend)
　{
　　Beep(100,100);
　　Sleep(1000);
　}
　：：PostMessage(hWnd,WM_USERMSG,0,0)；
　return 0;
}
////////WM_USERMSG消息的响应函数为OnThreadended(WPARAM wParam,
LPARAM lParam)
LONG CTestView::OnThreadended(WPARAM wParam,LPARAM lParam)
{
　AfxMessageBox("Thread ended.");
　Retrun 0;
}
　　上面的例子是工作者线程向用户界面线程发送消息，对于工作者线程，如果它的设计模式也是消息驱动的，那么调用者可以向它发送初始化、退出、执行某种特定的处理等消息，让它在后台完成。在控制函数中可以直接使用：：GetMessage()这个SDK函数进行消息分检和处理，自己实现一个消息循环。GetMessage()函数在判断该线程的消息队列为空时，线程将系统分配给它的时间片让给其它线程，不无效的占用CPU的时间，如果消息队列不为空，就获取这个消息，判断这个消息的内容并进行相应的处理。

　　（二）用事件对象实现通信

　　在线程之间传递信号进行通信比较复杂的方法是使用事件对象，用MFC的Cevent类的对象来表示。事件对象处于两种状态之一：有信号和无信号，线程可以监视处于有信号状态的事件，以便在适当的时候执行对事件的操作。上述例子代码修改如下：

////////////////////////////////////////////////////////////////////
Cevent threadStart ,threadEnd;
UINT ThreadFunction(LPVOID pParam)
{
　：：WaitForSingleObject(threadStart.m_hObject,INFINITE);
　AfxMessageBox("Thread start.");
　while(!bend)
　{
　　Beep(100,100);
　　Sleep(1000);
　　Int result=::WaitforSingleObject(threadEnd.m_hObject,0);
　　//等待threadEnd事件有信号，无信号时线程在这里悬停
　　If(result==Wait_OBJECT_0)
　　　Bend=TRUE;
　}
　：：PostMessage(hWnd,WM_USERMSG,0,0)；
　return 0;
}
/////////////////////////////////////////////////////////////
Void CtestView::OninitialUpdate()
{
　hWnd=GetSafeHwnd();
　threadStart.SetEvent();//threadStart事件有信号
　pThread=AfxBeginThread(ThreadFunction,hWnd);//启动线程
　pThread->m_bAutoDelete=FALSE;
　Cview::OnInitialUpdate();
}
////////////////////////////////////////////////////////////////
Void CtestView::OnDestroy()
{
　threadEnd.SetEvent();
　WaitForSingleObject(pThread->m_hThread,INFINITE);
　delete pThread;
　Cview::OnDestroy();
}
　　运行这个程序，当关闭程序时，才显示提示框，显示"Thread ended"。
论4：线程之间的同步

　　前面我们讲过，各个线程可以访问进程中的公共变量，所以使用多线程的过程中需要注意的问题是如何防止两个或两个以上的线程同时访问同一个数据，以免破坏数据的完整性。保证各个线程可以在一起适当的协调工作称为线程之间的同步。前面一节介绍的事件对象实际上就是一种同步形式。Visual C++中使用同步类来解决操作系统的并行性而引起的数据不安全的问题，MFC支持的七个多线程的同步类可以分成两大类：同步对象（CsyncObject、Csemaphore、Cmutex、CcriticalSection和Cevent）和同步访问对象（CmultiLock和CsingleLock）。本节主要介绍临界区（critical section）、互斥（mutexe）、信号量（semaphore），这些同步对象使各个线程协调工作，程序运行起来更安全。

　　（一） 临界区

　　临界区是保证在某一个时间只有一个线程可以访问数据的方法。使用它的过程中，需要给各个线程提供一个共享的临界区对象，无论哪个线程占有临界区对象，都可以访问受到保护的数据，这时候其它的线程需要等待，直到该线程释放临界区对象为止，临界区被释放后，另外的线程可以强占这个临界区，以便访问共享的数据。临界区对应着一个CcriticalSection对象，当线程需要访问保护数据时，调用临界区对象的Lock()成员函数；当对保护数据的操作完成之后，调用临界区对象的Unlock()成员函数释放对临界区对象的拥有权，以使另一个线程可以夺取临界区对象并访问受保护的数据。同时启动两个线程，它们对应的函数分别为WriteThread()和ReadThread()，用以对公共数组组array[]操作，下面的代码说明了如何使用临界区对象：

#include "afxmt.h"
int array[10],destarray[10];
CCriticalSection Section;
UINT WriteThread(LPVOID param)
{
　Section.Lock();
　for(int x=0;x<10;x++)
　　array[x]=x;
　Section.Unlock();
}
UINT ReadThread(LPVOID param)
{
　Section.Lock();
　For(int x=0;x<10;x++)
　　Destarray[x]=array[x];
　　Section.Unlock();
}
　　上述代码运行的结果应该是Destarray数组中的元素分别为1-9，而不是杂乱无章的数，如果不使用同步，则不是这个结果，有兴趣的读者可以实验一下。

　　（二）互斥

　　互斥与临界区很相似，但是使用时相对复杂一些，它不仅可以在同一应用程序的线程间实现同步，还可以在不同的进程间实现同步，从而实现资源的安全共享。互斥与Cmutex类的对象相对应，使用互斥对象时，必须创建一个CSingleLock或CMultiLock对象，用于实际的访问控制，因为这里的例子只处理单个互斥，所以我们可以使用CSingleLock对象，该对象的Lock()函数用于占有互斥，Unlock()用于释放互斥。实现代码如下：

#include "afxmt.h"
int array[10],destarray[10];
CMutex Section;

UINT WriteThread(LPVOID param)
{
　CsingleLock singlelock;
　singlelock (&Section);
　singlelock.Lock();
　for(int x=0;x<10;x++)
　　array[x]=x;
　singlelock.Unlock();
}

UINT ReadThread(LPVOID param)
{
　CsingleLock singlelock;
　singlelock (&Section);
　singlelock.Lock();
　For(int x=0;x<10;x++)
　　Destarray[x]=array[x];
　　singlelock.Unlock();
}
　　（三）信号量

　　信号量的用法和互斥的用法很相似，不同的是它可以同一时刻允许多个线程访问同一个资源，创建一个信号量需要用Csemaphore类声明一个对象，一旦创建了一个信号量对象，就可以用它来对资源的访问技术。要实现计数处理，先创建一个CsingleLock或CmltiLock对象，然后用该对象的Lock()函数减少这个信号量的计数值，Unlock()反之。下面的代码分别启动三个线程，执行时同时显示二个消息框，然后10秒后第三个消息框才得以显示。

/////////////////////////////////////////////////////////////////////////
Csemaphore *semaphore;
Semaphore=new Csemaphore(2,2);
HWND hWnd=GetSafeHwnd();
AfxBeginThread(threadProc1,hWnd);
AfxBeginThread(threadProc2,hWnd);
AfxBeginThread(threadProc3,hWnd);
UINT ThreadProc1(LPVOID param)
{
　CsingleLock singelLock(semaphore);
　singleLock.Lock();
　Sleep(10000);
　::MessageBox((HWND)param,"Thread1 had access","Thread1",MB_OK);
　return 0;
}
UINT ThreadProc2(LPVOID param)
{
　CSingleLock singelLock(semaphore);
　singleLock.Lock();
　Sleep(10000);
　::MessageBox((HWND)param,"Thread2 had access","Thread2",MB_OK);
　return 0;
}

UINT ThreadProc3(LPVOID param)
{
　CsingleLock singelLock(semaphore);
　singleLock.Lock();
　Sleep(10000);
　::MessageBox((HWND)param,"Thread3 had access","Thread3",MB_OK);
　return 0;
}

 

VC多线程之线程间的通信 http://www.ibiancheng.cn/Article/VCWin32Article/200802/110.html

论5：线程之间的同步

 相比于进程间通信来说，线程间通信无疑是相对比较简单的。

   首先我们来看看最简单的方法，那就是使用全局变量（静态变量也可以）来进行通信，由于属于同一个进程的各个线程是处于同一个进程空间中的，并且它们共享这个进程的各种资源，因此它们都可以毫无障碍的访问这个进程中的全局变量。当需要有多个线程来访问一个全局变量时，通常我们会在这个全局变量前加上volatile声明，来告诉编译器这个全局变量是易变的，让编译器不要对这个变量进行优化（至于编译器到底有没有按照你的要求来对volatile进行处理这个暂且不理）。

   下面贴出一段简单的示例代码：

#include  " stdafx.h "
#include  " windows.h "
#include  " stdio.h "

volatile   int  ThreadData  =   0 ;

void  ThreadProcess()
{
    for(int i=0; i<6; i++)
    {
        ThreadData += 1000;
        Sleep(1000);
        printf("Sub  Thread Tick %5d! %5d\n",(i+1)*1000, ThreadData);
    }
    printf("Exit Sub Thread!\n");
    
}

int  _tmain( int  argc, _TCHAR *  argv[])
{
    HANDLE hThread;
    DWORD ThreadID;
    hThread=CreateThread(NULL,
                     0,
                     (LPTHREAD_START_ROUTINE)ThreadProcess,
                     NULL,
                     0,
                     &ThreadID);
    
    for(int i=0; i<10; i++)
    {
        ThreadData -= 600;
        Sleep(600);
        printf("Main Thread Tick %5d! %5d\n", (i+1)*600, ThreadData);
    }
    printf("Main Thread Loop Finished! \n");
    system("pause");
    return 0;
}

   除了全局变量之外，还有其他的方法，比如利用消息机制等来实现线程间通信。这个就不详细解释了，关于消息机制，详情请看Windows消息机制概述 。 

   下面，关于多线程中的全局变量，我来介绍点有点偏题的东西：
线程局部存储（TLS）
    进程中的全局变量与函数内定义的静态(static)变量，是各个线程都可以访问的共享变量。在一个线程修改的内存内容，对所有线程都生效。这是一个优点也是一个缺点。说它是优点，线程的数据交换变得非常快捷。说它是缺点，一个线程死掉了，其它线程也性命不保; 多个线程访问共享数据，需要昂贵的同步开销，也容易造成同步相关的BUG。
　　如果需要在一个线程内部的各个函数调用都能访问、但其它线程不能访问的变量（被称为static memory local to a thread 线程局部静态变量），就需要新的机制来实现。这就是TLS。
　　线程局部存储在不同的平台有不同的实现，可移植性不太好。　
　　方法一：每个线程创建时系统给它分配一个LPVOID指针的数组（叫做TLS数组），这个数组从C编程角度是隐藏着的不能直接访问，需要通过一些C API函数调用访问。首先定义一些DWORD线程全局变量或函数静态变量,准备作为各个线程访问自己的TLS数组的索引变量。一个线程使用TLS时，第一步在线程内调用TlsAlloc()函数，为一个TLS数组索引变量与这个线程的TLS数组的某个槽(slot）关联起来，例如获得一个索引变量：
　　global_dwTLSindex=TLSAlloc();
　　注意，此步之后，当前线程实际上访问的是这个TLS数组索引变量的线程内的拷贝版本。也就说，不同线程虽然看起来用的是同名的TLS数组索引变量，但实际上各个线程得到的可能是不同DWORD值。其意义在于，每个使用TLS的线程获得了一个DWORD类型的线程局部静态变量作为TLS数组的索引变量。C/C++原本没有直接定义线程局部静态变量的机制，所以在如此大费周折。
　　第二步，为当前线程动态分配一块内存区域（使用LocalAlloc()函数调用），然后把指向这块内存区域的指针放入TLS数组相应的槽中(使用TlsValue()函数调用)。
　　第三步，在当前线程的任何函数内，都可以通过TLS数组的索引变量，使用TlsGetValue()函数得到上一步的那块内存区域的指针，然后就可以进行内存区域的读写操作了。这就实现了在一个线程内部这个范围处处可访问的变量。
　　最后，如果不再需要上述线程局部静态变量，要动态释放掉这块内存区域(使用LocalFree()函数)，然后从TLS数组中放弃对应的槽(使用TlsFree()函数）。
　　方法二：
　　直接声明这个变量是各个线程有自己拷贝的线程局部静态变量：
　　__declspec( thread ) int var_name;

 

from：http://blog.csdn.net/jtop0/article/details/7438817