C++ C++；多线程算法创建在同一CPU线程上运行的多个线程

我是多线程新手，我会尽可能的清晰。在C++中，我用标准库STD:：线程创建了一个多线程算法。我的代码正在编译和运行，没有错误。我把代码放在两个线程上。创建的两个线程的id与主线程不同（我使用getid（）和Visual Studio中的线程窗口进行了检查）。问题是我没有时间增益，CPU的利用率是相同的，所以它们似乎运行在同一个CPU线程上

这是否意味着线程并不自动意味着在不同的CPU内核和线程上运行以获得时间

我是否需要添加指令或将此代码与多线程库组合？还是只是一个错误？ 非常感谢您的帮助，谢谢

double internalenergy=0;
unsigned int NUM_THREADS = std::thread::hardware_concurrency();
NUM_THREADS=2;
 vtkIdType num_cells = referencemesh_->GetNumberOfCells();
 int start_node[8];
 int end_node[8];
 int intervalle=num_cells/NUM_THREADS;
for( unsigned int i=0; i < NUM_THREADS; ++i )
{
    start_node[i] = (float)num_cells*i/NUM_THREADS;       
    end_node[i]   = (float)num_cells*(i+1)/NUM_THREADS;
}
const double* pointeurpara;
pointeurpara=&params(0);

double value1=0;
double* P_value1;
P_value1=&value1;

double value2=0;
double* P_value2;
P_value2=&value2;

std::thread first(threadinternalenergy,activemesh,referencemesh_,start_node[0],P_value1,pointeurpara);
std::thread second (threadinternalenergy,activemesh,referencemesh_,start_node[1],P_value2,pointeurpara);
first.join(); 
second.join();
double displacementneighpoint=*P_value1+*P_value2;

双内能=0；
unsigned int NUM_THREADS=std:：thread:：hardware_concurrency（）；
线程数=2；
vtkIdType num_cells=referencemesh_uu->GetNumberOfCells（）；
int start_节点[8]；
int end_节点[8]；
int intervalle=num_单元/num_线程；
for（无符号整数i=0；i

以下是threadinternalenergy的源代码

void threadinternalenergy(vtkSmartPointer<vtkPolyData>, 
activemesh,vtkSmartPointer<vtkPolyData> referencemesh,int startcell,double* 
displacementneighpoint,const double* p) 
{
 unsigned long processnumber;
 processnumber=GetCurrentProcessorNumber();
 cout<<"process "<<processnumber<<endl;

unsigned int NUM_THREADS = std::thread::hardware_concurrency();
NUM_THREADS=2;
vtkIdType num_cells = referencemesh->GetNumberOfCells();
int intervalle=num_cells/NUM_THREADS;
int endcell=startcell+intervalle;
//cout<<"start cell "<<startcell<<endl;
//cout<<"end cell "<<endcell<<endl;
int numcell_th=startcell-endcell;

 vtkSmartPointer<vtkEdgeTable> vtk_edge_tableT = 
vtkSmartPointer<vtkEdgeTable>::New();
  vtk_edge_tableT->InitEdgeInsertion(numcell_th*3);

  // Initialize edge table
  vtkSmartPointer<vtkEdgeTable> vtk_edge_table = 
vtkSmartPointer<vtkEdgeTable>::New();
  vtk_edge_table->InitEdgeInsertion( numcell_th*3 );

  cout<<"start cell "<<startcell<<endl;

 for( vtkIdType i=startcell; i < endcell; ++i )
  {   
    vtkCell* cell = referencemesh->GetCell( i );
 // cout<<"cell"<<endl;
    // Traverse edges in cell -- assuming a linear cell (line, triangle; NOT 
  rectangle)
    for( vtkIdType j=0; j < cell->GetNumberOfEdges(); ++j )
    {
        // cout<<"edge"<<endl;
      vtkCell* edge = cell->GetEdge( j );

      vtkIdType pt0 = edge->GetPointId(0);
      vtkIdType pt1 = edge->GetPointId(1);


    //consider edge if a displacement has been point by at least one point
        //if(params(pt0)!=0 || params(pt1)!=0){


          if( vtk_edge_table->IsEdge( pt0, pt1 ) == -1 ){     // If this edge 
     is not in the edge table
                vtk_edge_table->InsertEdge( pt0, pt1 );
              //acess point coordinate
             // vtkPoints* listpoints=edge->GetPoints();
              double p0 [3];
              double p1 [3];
              referencemesh->GetPoint(pt0,p0);
              referencemesh->GetPoint(pt1,p1);


                //2e Mesh (Mesh transform)
                 double p0T [3];
              double p1T [3];
              activemesh->GetPoint(pt0,p0T);
              activemesh->GetPoint(pt1,p1T);


                    // If this edge is not in the edge table
                vtk_edge_tableT->InsertEdge( pt0, pt1 );


                //find displacement difference for 2 points sharing an edge
                double squaredDistancep0 = 
                vtkMath::Distance2BetweenPoints(p0, p0T);
                double distancep0 = sqrt(squaredDistancep0);
                double squaredDistancep1 = 
                vtkMath::Distance2BetweenPoints(p1, p1T);
                double distancep1 = sqrt(squaredDistancep1);
                double difference = abs(distancep0 - distancep1);
                difference=((difference+1)*(difference+1))-1;
                //if(difference>0.25){
                    //cout<<"grosse difference "<<difference<<endl;
                //}
                *displacementneighpoint+=difference;
                //displacementpointneigh.push_back(difference);



             }

        //}

    } 
  }
 cout<<"Fin du thread "<<endl;
 }

void threadinternalenergy（vtkSmartPointer，
activemesh，vtkSmartPointer referencemesh，int startcell，双精度*
位移邻近点，常数双*p）
{
无符号长进程数；
processnumber=GetCurrentProcessorNumber（）；
cout线程可能运行在不同的内核上。这并不一定意味着程序会更快。它可能会比使用一个线程运行得慢。线程必须同时完成足够的工作，以证明线程创建和同步的开销是合理的。有很多陷阱。一个可能的问题是线程是shar过于频繁地删除（或“错误共享”）内存

是的，线程背后的一个主要思想是“实现并发性”。但这可以用只有一个内核的CPU来实现！或者用很多内核就不能很好地实现

我写了一个系统来控制处理计算机晶圆的机器人。它运行在一个有一个内核的CPU上，但它强烈依赖于并发性。并发性是由CPU以外的设备同时运行造成的，例如伺服放大器和网卡。一个高优先级线程专门管理伺服通过网络。其他线程利用空闲时间规划轨迹，与主机通信等…当伺服控制线程醒来时，因为网卡收到伺服的响应，它立即接管CPU并完成其任务

今年在cppCon上有一个演讲题为“当一微秒是永恒的”.这家伙编写了一个狡猾的股票交易系统。对他来说，重要的是他能以多快的速度处理连接他与市场的网络。为了获得他所需要的吞吐量，他使用了一台禁用了三核的四核机器。为什么？因为他找不到足够好的单核机器

我还编写了一个类，它使用多线程在多核机器上进行一些计算。它失败得很惨。有些任务不适合分而治之。
平台？操作系统、硬件、编译器？你可以看到这个问题，了解更多信息。如果没有
threadinternalenergy
sourceWhy cast to
（浮动）
？您是否在任何地方使用
end\u node
？@M-ABouBou编辑您的问题并添加
threadinternalenergy
的源代码。更好的是，创建一个感谢，关于内存共享，线程确实都使用相同的数据：activemesh，它是否会造成增加时间的复杂性？我应该避免吗？就时间而言，通常需要1到2秒（用于进行数千次迭代的优化），1秒是否太短，无法使用多线程进行优化？当两个线程访问同一缓存线时，其中至少有一个线程正在写入缓存线，硬件或操作系统必须争先恐后地使它们达成一致。进行简单的缓存访问可能需要30倍的时间。我不能在这里给出任何教训。获取一本由了解更多相关知识的人编写的书好吧，它只是读取共享数据，但可能它仍然会做类似的事情…我会尝试找到更多的信息