不用信号量实现的生产者，消费者，

Question

大家指点一下，有没哟错误，隐患啊呵呵 
#include<deque>
using std::deque;#include<iostream>
using std::cout;
using std::endl; int const BUFFER_MAX_SIZE =10;deque<int>dq(BUFFER_MAX_SIZE); //BUFFER_MAX_SIZE个大小的缓冲区class CritHelper
{
临界区帮助类  raii
};class CritHelpIO //std::cout,std::endl; 防止 生产者，消费者以外的线程使用
{raii;
};//初始化数据，子线程以外先调用
void InitData()
{
deque<int>::iter =dq.begin();for(int i=1;(i<=BUFFER_MAX_SIZE )&& (iter!= dq.end()); i++)
{
*iter=0;
}}
//队列中添加数据
void put(int n)
{
CritHelper ch;if(dq.size()==BUFFER_MAX_SIZE) //满了
{
while(1){}; //等到有空位{
CritHelpIO chi;cout<<"进入的数据位:"<<n<<endl;}dq.push_back(n);}}
//获取数据
int get()
{CritHelper ch;if(dq.empty()) //空
{
while(1){}; //等到有数据{
CritHelpIO chi;cout<<"取出的数据位:"<<dq.front()<<endl;}dq.pop_front();}}
void Produce(int n)
{
for( int i=0 ;i<n ; i++)
{
put(i);
}
}
void Consumer(int n)
{
for( int i=0 ;i<n ; i++)
{
get();}}

Answer 1

InitData()里漏了 iter++
CritHelper ch; 不知是不是伪代码？局部的临界？这样用不行的吧
while(1){};不合理，会耗尽CPU，单线程下用，直接挂掉

Answer 2

while(1)是表示等待的意思啊
上完整代码:#include "stdafx.h"
#include <process.h>
#include <windows.h>
#include<deque>
using std::deque;#include<iostream>
using std::cout;
using std::endl;int const BUFFER_MAX_SIZE =10; //BUFFER_MAX_SIZE个大小的缓冲区deque<int>dq;class CritHelper
{
//临界区帮助类  raii
CRITICAL_SECTION cs;
public:
CritHelper()
{
::InitializeCriticalSection(&cs);
::EnterCriticalSection(&cs);
} ~CritHelper()
{
::LeaveCriticalSection(&cs);
::DeleteCriticalSection(&cs);
}};
class CritHelpIO
{
//临界区帮助类  raii
CRITICAL_SECTION cs;public:
CritHelpIO()
{
::InitializeCriticalSection(&cs);
::EnterCriticalSection(&cs);
} ~CritHelpIO()
{
::LeaveCriticalSection(&cs);
::DeleteCriticalSection(&cs);
}};
//初始化数据，子线程以外先调用
void InitData()
{
deque<int>::iterator iter =dq.begin(); for(int i=1;(i<=BUFFER_MAX_SIZE )&& (iter!= dq.end()); i++)
{
*iter=0;
}}
//队列中添加数据
void put(int n)
{
CritHelper ch; if(dq.size()==BUFFER_MAX_SIZE) //满了
{
while(1){}; //等到有空位 } {
CritHelpIO chi; cout<<"进入的数据位:"<<n<<endl; } dq.push_back(n);}
//获取数据
void get()
{ int val; CritHelper ch; if(dq.empty()) //空
{
while(1){}; //等到有数据 } val=dq.front(); {
CritHelpIO chi; cout<<"取出的数据位:"<<val<<endl; } dq.pop_front();}
unsigned int _stdcall Produce(VOID* n)
{
int*p =(int*)n; for( int i=0 ;i<*p ; i++)
{
put(i);
}
return 0;
}
unsigned int _stdcall Consumer(VOID* n)
{
int *p=(int*)n;
for( int i=0 ;i<*p ; i++)
{
get(); }
return 0;}int main()
{ int val=10;
HANDLE hWnd1=(HANDLE)_beginthreadex(NULL,0,Produce,&val,0,NULL);
HANDLE hWnd2=(HANDLE)_beginthreadex(NULL,0,Produce,&val,0,NULL); int val2=20;
HANDLE hWnd3=(HANDLE)_beginthreadex(NULL,0,Consumer,&val2,0,NULL); Sleep(50000); return 0;}

Answer 3

1.InitData这个函数 基本报废了看 2楼2.  我实现了代码，你看对不对3，while(1);为什么不合理，难道 ::Sleep(几秒钟) ????

Answer 4

while(1){}你在这死循环是干什么？

Answer 5

InitData虽没调用到，但要提一下iterator的用法
    deque<int>::iterator iter =dq.begin();    for(; iter!= dq.end(); iter++) //这样就可以了，不要搞太复杂
    {
        *iter=0;
    }while(1)用错了
正确的应是
while(dq.empty()); //空，等到有数据
while(dq.size() == BUFFER_MAX_SIZE); //满了，等到有空位不过不建议这么做
while(表达式); 这个无法预测结束时机，可能一直死循环，会消耗大量CPU资源
可以加Sleep(0)，但还是不够理想
raii用法错
CritHelper ch;
CritHelpIO chi;
都是局部对象，注意其生存期（只在函数内或函数某代码块内），不能起到全局临界的作用（这里的函数都是全局 ）
而且有大错误就是在构造里InitializeCriticalSection、在析构里DeleteCriticalSection正确用法是
建一个CCriticalSection类，构造里InitializeCriticalSection，析构里DeleteCriticalSection，并且要保证CRITICAL_SECTION cs的生存期有效（如要放在全局区里）
CritHelper只负责EnterCriticalSection和LeaveCriticalSection

Answer 6

今早看了会资料，发现错误很多1 一般是用 信号量，之所以用信号量，原因：可以使多个线程同时访问 同一资源比如 8个生产者线程（缓冲区大小为5,，循环队列作为缓冲区，可以用数组实现 )  ，8个消费者(至少是0个消费者在访问缓冲区域，最多5个消费者线程访问缓冲区）我的那个代码无法做到 这点2. raii用法错误。如果去掉，按照我的做法，虽然有3个子线程运行，但是违背了原意： 2个同时在运行的生产者。

Answer 7

另外：把题目改成 1个生产者，1个消费者的模型代码也是有问题的，
//队列中添加数据
void put(int n)
{
    CritHelper ch;    if(dq.size()==BUFFER_MAX_SIZE) //满了
    {
        while(1){};        //等到有空位    }
不知道何时有有空位， Sleep的话，但是时间不好设置。

Answer 8

用信号量解决的问题，
1个生产者 1个消费者。
  g_hFullSemaphore   =   CreateSemaphore(NULL,1,1,NULL);
               
          g_hEmptySemaphore   =   CreateSemaphore(NULL,0,1,NULL);   //生产者
  DWORD     WINAPI   Producer(LPVOID   lpPara)   
  {   
          while(g_continue){   
                  WaitForSingleObject(g_hFullSemaphore,INFINITE);   
 
  WaitForSingleObject(g_hMutex,INFINITE);   
                  Produce();   
                  Append();   
                  Sleep(1500);   

                  ReleaseMutex(g_hMutex);   
                  ReleaseSemaphore(g_hEmptySemaphore,1,NULL); //唤醒消费者
 
 
          }   
          return   0;   
  }     //消费者
  DWORD     WINAPI   Consumer(LPVOID   lpPara)   
  {   
          while(g_continue){   
                  WaitForSingleObject(g_hEmptySemaphore,INFINITE);   
                  WaitForSingleObject(g_hMutex,INFINITE);   
                  Take();   
                  Consume();   
                  Sleep(1500);   
                  ReleaseMutex(g_hMutex);   
                  ReleaseSemaphore(g_hFullSemaphore,1,NULL);    //唤醒生产者 
          }   
          return   0;   
  }