求助高手解释程序~(关于生产者-消费者问题)

               
          g_hEmptySemaphore   =   CreateSemaphore(NULL,0,SIZE_OF_BUFFER-1,NULL);   
    
    
          const   unsigned   short   PRODUCERS_COUNT   =   3;     //生产者的个数   
          const   unsigned   short   CONSUMERS_COUNT   =   1;     //消费者的个数   
          const   unsigned   short   THREADS_COUNT   =   PRODUCERS_COUNT+CONSUMERS_COUNT;        //总的进程数   
    
          HANDLE   hThreads[PRODUCERS_COUNT];   //各线程的handle   
          DWORD   producerID[CONSUMERS_COUNT];   //生产者线程的标识符   
          DWORD   consumerID[THREADS_COUNT];   //消费者线程的标识符   
    
  //加注释，说明该For循环的作用
          for   (int   i=0;i<PRODUCERS_COUNT;++i){   
                  hThreads[i]=CreateThread(NULL,0,Producer,NULL,0,&producerID[i]);   
  //加注释，说明上面函数的功能，各参数的含义       
                  if   (hThreads[i]==NULL)   return   -1;   
          }   
         
  //加注释，说明该For循环的作用
          for   ( i=0;i<CONSUMERS_COUNT;++i){   
                  hThreads[PRODUCERS_COUNT+i]=CreateThread(NULL,0,Consumer,NULL,0,&consumerID[i]);   
                  if   (hThreads[i]==NULL)   return   -1;   


          }   
    
          while(g_continue){   
                  if(getchar()){   //按回车后终止程序运行   
                          g_continue   =   false;   
                  }   
          }   
    
          return   0;   
  }   
    
 //加注释，说明下面函数的功能
  void   Produce()   
  {   
          std::cerr   <<   "Producing   "   <<   ++ProductID   <<   "   ...   ";   
          std::cerr   <<   "Succeed"   <<   std::endl;   
  }   
    
//加注释，说明下面函数的功能
  void   Append()   
  {   
          std::cerr   <<   "Appending   a   product   ...   ";   
          g_buffer[in]   =   ProductID;   
          in   =   (in+1)%SIZE_OF_BUFFER;   
          std::cerr   <<   "Succeed"   <<   std::endl;   
    
          //输出缓冲区当前的状态   
          for   (int   i=0;i<SIZE_OF_BUFFER;++i){   
                  std::cout   <<   i   <<":   "   <<   g_buffer[i];   


                  if   (i==in)   std::cout   <<   "   <--   生产";   
                  if   (i==out)   std::cout   <<   "   <--   消费";   
                  std::cout   <<   std::endl;   
          }   
  }   
 //加注释，说明下面函数的功能   
  void   Take()   
  {   
          std::cerr   <<   "Taking   a   product   ...   ";   
          ConsumeID   =   g_buffer[out];   
          out   =   (out+1)%SIZE_OF_BUFFER;   
          std::cerr   <<   "Succeed"   <<   std::endl;   
    
          //输出缓冲区当前的状态   
          for   (int   i=0;i<SIZE_OF_BUFFER;++i){   
                  std::cout   <<   i   <<":   "   <<   g_buffer[i];   
                  if   (i==in)   std::cout   <<   "   <--   生产";   
                  if   (i==out)   std::cout   <<   "   <--   消费";   
                  std::cout   <<   std::endl;   


          }   
  }   
  //加注释，说明下面函数的功能
  void   Consume()   
  {   
          std::cerr   <<   "Consuming   "   <<   ConsumeID   <<   "   ...   ";   
          std::cerr   <<   "Succeed"   <<   std::endl;   
  }   
  
  //加注释，说明下面函数的功能
  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;   
  }