Question

我有一个要求，我必须在套接字上写，然后从套接字连续读取响应并处理数据。我创建了2个A和B类.A有write（）和read（）api，B有processdata（）api。我已经创建了从A :: read（）到B :: processdata（）的回调。但我面临多线程问题，因为我是新手。 read（）api的线程必须始终运行，但是在B :: processdata（）中处理数据时，服务器正在发送一些我缺少的socket read（）上的数据。请为这个问题建议一些设计，以便我可以继续存储数据，同时我的processdata功能可以完成其工作，并可以再次回来读取数据（用小例子）？我正在考虑维护3个线程，每次写入1次，读取和处理数据。但是我不确定如何在完成processdata线程后回过头来阅读线程。

对于这篇长篇文章感到抱歉，但如果有人能帮助我，我将不胜感激。

以下是我在项目中的高级代码设计。

 //A.cpp
        class A {
        public:
          void  write();
           void read(b* obj);
        }
        void A::write()
        { 
           //code to write to socket  

          }
        void A::read(b* obj)
        { 
           //code to read from socket  
          // if data received call below function 
          obj->processdata(buffer)
          }

    //B.cpp    
        class B {
        public:
            processdata(buffer)
        }

        void B::processdata(buffer)
        { 
           //code to processdaata from socket  
          }
//Main.cpp
        int main()
        {
          A* objA = new A;
          B* objB = new B;
          objA->write()
          while(1)
           {
             objA->read(objB)
            }
        }

Answer 1

A.cpp

extern  CRITICAL_SECTION    g_cCritSec;
        class A {
        public:
          static void  write();
          static void read(void* obj);
        }
        void A::write()
        { 

           EnterCriticalSection(&g_cCritSec);
           //code to write to socket 
           LeaveCriticalSection(&g_cCritSec); 

        }
        void A::read(void* obj)
        { 
           EnterCriticalSection(&g_cCritSec);
           while(1)
           {
              //code to read from socket  
              // if data received call below function 
              // send separate copy of buffer to avoid overrite
              uintptr_t Thread2 = _beginthread( B::processdata, 0, (void *) buffer); 

              //obj->processdata(buffer)
           }
           LeaveCriticalSection(&g_cCritSec);
        }

B.cpp

  extern    CRITICAL_SECTION    g_cCritSec;
        class B {
        public:
            static processdata( void *buffer)
        }

        void B::processdata(void *buffer)
        {  
           Buffer *bufferReceive = (Buffer*)buffer;
           //code to processdaata from socket   
        }

Main.cpp的

CRITICAL_SECTION    g_cCritSec;
        int main()
        {

          InitializeCriticalSection(&g_cCritSec); 
          B* objB = new B;
          objA->write();
          uintptr_t Thread1 = _beginthread( A::read, 0, (void *) objB); 

          DeleteCriticalSection(&g_cCritSec); 
        }

这个答案对你有帮助吗？一个最小的多线程应用程序，它将作为例程启动Thread1作为静态memeber函数A::Read（我们需要将memeber函数定义为静态以用作线程回调）。从Read函数开始，它将启动另一个传递buffer副本的线程。这两个线程将同时执行

用于在c ++中读写SERVER的多线程

1 个答案: