C++ 使用互斥增强锁定向量

我正在为路由器编写代码，我想在接收线程上接收到一个数据包后，将该数据包（目前为“unsigned char*”类型）存储在一个向量中。我有两个连接到两个不同接口的接收器线程，如果另一个线程没有访问向量，那么接收器线程应该只存储接收到的数据包

除了两个接收线程之外，我将有一个处理数据包的主线程和两个发送线程，每个接口一个。总线程数为5。为了防止不同线程从向量中写入或读取时出现问题，我听说有一个互斥锁，它应该为其他（在本例中）线程锁定向量，直到相关线程从向量中读取或写入完毕

我想知道的是如何将其处理为代码。请举一些例子。对于C++、Boost和SooSosits，我都是新手。在C++中，我不太喜欢使用不同的类。我很清楚他们在爪哇和C中的工作原理，但是我发现C++是非常不同的（因为头文件）。我将所有代码都放在一个巨大的主类中，这可能不是很好的编码风格，但这就是它目前的工作方式

我应该创建一个类（.h和.cpp文件）来处理这个向量，还是应该在我庞大的主类中实现它，如果是这样的话，我将非常乐意提供一些简单的示例。下面是我希望我的程序如何工作的一个例子。我已经有了RecvThread，并且我能够打印出数据包的MAC Hdr

void RecvThread()
{
    //receive a packet


    while(true)
    {
        //get lock status from vector

        if(vector is locked)
        {
            usleep(10000);
        }
        else
        {
            //lock vector
            //save packet in vector
            //unlock vector
        }
    }
}

void SendThread()
{
    while(true)
    {
        //get lock status from vector

        if(vector is locked)
        {
            usleep(10000);
        }
        else
        {
            //lock vector
            //get packet from vector
            //unlock vector
        }
    }

    //send the packet
}

void MainThread()
{

    while(true)
    {
        if(recv vector is empty)
        {
            usleep(10000);
        }
        else if(recv vector is locked)
        {
            usleep(10000);
        }
        else
        {
            //lock recv vector
            //get packet in front of queue
            //unlock recv vector
            //process packet (update different fields)
            //get packet interface (either 1 or 2)
            if(send vector (matching interface) is locked)
            {
                usleep(10000);
            }
            else
            {
                //lock send vector (matching interface)
                //save packet to send vector (matching interface)
                //unlock send vector (matching interface)
            }
        }
    }
}

int main()
{
    //create Recv vector
    //create Send vector 1 and 2 (one for each interface)
    //create and join RecvThread 1 and 2
    //create and join SendThread 1 and 2
    //create and join MainThread
}

---

希望这能给你一个想法。没有测试它，因为它显然不完整：） 钥匙是

boost:：lock\u guard lock（mx\ux）因为此行一次只能由一个线程执行。实际发生的是，例如线程A调用了这个函数，因为它是第一个到达那里的线程
boost:：lock\u guard lock（mx\ux）
立即返回，线程可以进入所谓的关键部分（锁后的代码段）。基本上
boost:：lock\u guard lock（mx\ux）仅当临界段内没有其他线程时返回。如果关键部分已经被另一个线程访问，
boost:：lock\u guard lock（mx\ux）在另一个线程离开关键部分之前不会返回。为了让等待的线程现在继续，需要解锁互斥锁。在boost中，一旦阻塞线程（第一个进入该节的线程）离开函数的作用域和临界节，就会自动执行此操作。离开作用域将销毁变量
mx
，该变量允许创建并锁定另一个同名互斥体

编辑：您不会专门锁定一个变量，例如向量。锁定代码的一段，在该段中访问该变量

class Receiver{
private:
  boost::mutex mx_;
  int *data_;   // I need protection

public:
  bool receive_data(){
    // Prepare connection and do some stuff...

    void some_function(){
      // Before we access data_, we need to make sure only the current thread does so.
      // Mutex will unlock once the scope of this function is left
      boost::lock_guard<boost::mutex> lock(mx_); 

      // Access data_ here (mutex is locked)
      //....
    } // End of scope and mutex unlocks automatically since it's destroyed
    return true;  // Will unlock the mutex since the function's scope is left. 
  }
};

类接收器{
私人：
boost：：互斥mx；
int*data；//我需要保护
公众：
bool接收_数据（）{
//准备连接并做一些事情。。。
使某些函数无效（）{
//在访问数据之前，我们需要确保只有当前线程这样做。
//一旦离开此函数的作用域，互斥锁将解锁
boost:：lock_guard lock（mx_）；
//在此处访问数据（互斥锁已锁定）
//....
}//作用域结束，互斥锁被销毁后自动解锁
return true；//将解锁互斥锁，因为函数的作用域已离开。
}
};
希望这能给你一个想法。没有测试它，因为它显然不完整：）
钥匙是
boost:：lock\u guard lock（mx\ux）因为此行一次只能由一个线程执行。实际发生的是，例如线程A调用了这个函数，因为它是第一个到达那里的线程
boost:：lock\u guard lock（mx\ux）
立即返回，线程可以进入所谓的关键部分（锁后的代码段）。基本上
boost:：lock\u guard lock（mx\ux）仅当临界段内没有其他线程时返回。如果关键部分已经被另一个线程访问，
boost:：lock\u guard lock（mx\ux）在另一个线程离开关键部分之前不会返回。为了让等待的线程现在继续，需要解锁互斥锁。在boost中，一旦阻塞线程（第一个进入该节的线程）离开函数的作用域和临界节，就会自动执行此操作。离开作用域将销毁变量
mx
，该变量允许创建并锁定另一个同名互斥体

编辑：您不会专门锁定一个变量，例如向量。锁定代码的一段，在该段中访问该变量

class Receiver{
private:
  boost::mutex mx_;
  int *data_;   // I need protection

public:
  bool receive_data(){
    // Prepare connection and do some stuff...

    void some_function(){
      // Before we access data_, we need to make sure only the current thread does so.
      // Mutex will unlock once the scope of this function is left
      boost::lock_guard<boost::mutex> lock(mx_); 

      // Access data_ here (mutex is locked)
      //....
    } // End of scope and mutex unlocks automatically since it's destroyed
    return true;  // Will unlock the mutex since the function's scope is left. 
  }
};

类接收器{
私人：
boost：：互斥mx；
int*data；//我需要保护
公众：
bool接收_数据（）{
//准备连接并做一些事情。。。
使某些函数无效（）{
//在访问数据之前，我们需要确保只有当前线程这样做。
//一旦离开此函数的作用域，互斥锁将解锁
boost:：lock_guard lock（mx_）；
//在此处访问数据（互斥锁已锁定）
//....
}//作用域结束，互斥锁被销毁后自动解锁
return true；//将解锁互斥锁，因为函数的作用域已离开。
}
};
您可以在没有类的情况下使用.h文件和.cpp。如果在其中一个类中写入单词class，那么就有一个类。在这种情况下，您将锁定一个互斥体，在其中写入//lock vector注释。不过，您不需要获得锁定状态，boost库将为您处理该状态。您可以使用.h文件和.cpp而无需类。如果在其中一个类中写入单词class，那么就有一个类。在这种情况下，您将锁定一个互斥体，在其中写入//lock vector注释。你不需要得到锁的状态，但是，推进l