如何在多个线程中使用单个对象?
How to use a single object in multiple threads?
我想使用 C++ 在多个线程中使用单个对象。我从 java 知道线程共享所有变量,但在 c++ 中似乎有所不同。
我有以下结构来存储日期
Class Flow: has multiple integers
Class UE: has a list<Flow*>
Class FlowTable: has a map<int,UE*>
现在有两个线程(对象:InOutReader 和 OutInReader),每个线程都有一个 FlowTable* 并且应该读取 and/or 向 FlowTable 插入数据。
在我的 starter 的 main() 中,我调用了 new FlowTable(),创建线程对象并使用 setter 将 FlowTable* 提供给它们。但最后看起来这两个线程使用不同的 FlowTable 对象。
class InOutReader{
public:
start(){
while(true){
//read data from somewhere(tap-interface1)
//extract address from ip packet and tcp/udp header etc
Flow* myflow = new Flow(IPsrc,IPdest);
this->myflowTable->insertFlow(myflow);
}
}
}
class OutInReader{
public:
start(){
while(true){
//read data from somewhere(tap-interface1)
//extract address from ip packet and tcp/udp header etc
Flow* myflow = new Flow(IPsrc,IPdest);
this->myflowTable->existsFlow(myflow);// should return true if a flow with the same data was inserted before
}
}
}
主程序
流表* myflowTable;
startThreadOne(){
InOutReader ior = InOutReader();
ior.setFlowTable(myFlowTable);
ior.start();
}
startThreadtwo(){
InOutReader oir = InOutReader();
oir.setFlowTable(myFlowTable);
oir.start();
}
void main(){
myFlowTable = new FlowTable();
std::thread t1 = std::thread(startThreadOne);
std::thread t2 = std::thread(startThreadtwo);
t1.join();
t2.join();
}
要在多个线程中使用同一个 FlowTable 对象,我必须做什么?
我无法理解你的解释,但是如果你想让两个线程共享相同的动态分配 FlowTable
,C++ 中的解决方案非常简单:
int
main()
{
FlowTable* sharedFlowTable = new FlowTable();
std::thread t1( startThread1, sharedFlowTable );
std::thread t2( startThread2, sharedFlowTable );
// ...
}
然后声明 startThread1
和 startThread2
以 FlowTable*
作为参数。 (这比 Java 中简单得多;在 Java 中,您必须为每个线程定义一个 class,派生自 Runnable
,并给每个 class 一个构造函数,它接受一个 FlowTable
,并将它复制到一个成员变量,以便 run
函数可以找到它。)
编辑:
当然,如果sharedFlowTable
指向的值确实是一个FlowTable
,并且不涉及继承和工厂函数,那么可以直接将其设为[=20=中的局部变量],而不是指针,并将 &sharedFlowTable
传递给线程。这在 C++ 中会更简单、更惯用。 (我必须感谢 @5gon12eder 指出了这一点。令人尴尬的是,因为除非有必要,否则我通常是反对动态分配的人。)
我想使用 C++ 在多个线程中使用单个对象。我从 java 知道线程共享所有变量,但在 c++ 中似乎有所不同。
我有以下结构来存储日期
Class Flow: has multiple integers
Class UE: has a list<Flow*>
Class FlowTable: has a map<int,UE*>
现在有两个线程(对象:InOutReader 和 OutInReader),每个线程都有一个 FlowTable* 并且应该读取 and/or 向 FlowTable 插入数据。
在我的 starter 的 main() 中,我调用了 new FlowTable(),创建线程对象并使用 setter 将 FlowTable* 提供给它们。但最后看起来这两个线程使用不同的 FlowTable 对象。
class InOutReader{
public:
start(){
while(true){
//read data from somewhere(tap-interface1)
//extract address from ip packet and tcp/udp header etc
Flow* myflow = new Flow(IPsrc,IPdest);
this->myflowTable->insertFlow(myflow);
}
}
}
class OutInReader{
public:
start(){
while(true){
//read data from somewhere(tap-interface1)
//extract address from ip packet and tcp/udp header etc
Flow* myflow = new Flow(IPsrc,IPdest);
this->myflowTable->existsFlow(myflow);// should return true if a flow with the same data was inserted before
}
}
}
主程序 流表* myflowTable;
startThreadOne(){
InOutReader ior = InOutReader();
ior.setFlowTable(myFlowTable);
ior.start();
}
startThreadtwo(){
InOutReader oir = InOutReader();
oir.setFlowTable(myFlowTable);
oir.start();
}
void main(){
myFlowTable = new FlowTable();
std::thread t1 = std::thread(startThreadOne);
std::thread t2 = std::thread(startThreadtwo);
t1.join();
t2.join();
}
要在多个线程中使用同一个 FlowTable 对象,我必须做什么?
我无法理解你的解释,但是如果你想让两个线程共享相同的动态分配 FlowTable
,C++ 中的解决方案非常简单:
int
main()
{
FlowTable* sharedFlowTable = new FlowTable();
std::thread t1( startThread1, sharedFlowTable );
std::thread t2( startThread2, sharedFlowTable );
// ...
}
然后声明 startThread1
和 startThread2
以 FlowTable*
作为参数。 (这比 Java 中简单得多;在 Java 中,您必须为每个线程定义一个 class,派生自 Runnable
,并给每个 class 一个构造函数,它接受一个 FlowTable
,并将它复制到一个成员变量,以便 run
函数可以找到它。)
编辑:
当然,如果sharedFlowTable
指向的值确实是一个FlowTable
,并且不涉及继承和工厂函数,那么可以直接将其设为[=20=中的局部变量],而不是指针,并将 &sharedFlowTable
传递给线程。这在 C++ 中会更简单、更惯用。 (我必须感谢 @5gon12eder 指出了这一点。令人尴尬的是,因为除非有必要,否则我通常是反对动态分配的人。)