用于在 C++ 中读取和写入 SERVER 的多线程

Question

我有一个要求，我必须在套接字上写入，然后从套接字连续读取响应并处理数据。 我创建了 2 个类 A 和 B。A 有 write() 和 read() api，B 有 processdata() api。 我创建了从 A::read() 到 B::processdata() 的回调。 但是我正面临多线程问题，因为我是新手。 read() api 的线程必须始终运行，但是在处理 B::processdata() 中的数据时，服务器正在我丢失的套接字 read() 上发送更多数据。 请为此问题提出一些设计建议，以便我可以继续存储数据，而我的 processdata 函数可以完成其工作并可以再次回来读取数据（带有小示例）？ 我正在考虑维护 3 个线程，每个 write 、 read 和 processdata 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 作为静态成员函数 A::Read 作为例程（我们需要将成员函数定义为静态以用作线程回调）。从Read 函数，它将启动另一个线程，并将buffer 的副本传递给它。这里两个线程将同时执行