在单独的线程中处理矢量元素

Process vector elements in separate threads

本文关键字：元素 处理 单独 线程      更新时间：2023-10-16

我试图在单独的线程中处理向量的元素，并将结果放在不同的向量中。我已经尝试过使用互斥锁和代码的关键部分，在这些部分中，我检查并从输入向量中取出元素，但在运行代码时，我会遇到访问冲突。

编辑：我已经更新了代码，将结果放回不同关键部分的向量中，并在线程开始之前初始化向量。

#include "stdafx.h"
#include <windows.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <conio.h>
#include <process.h>
#include <iostream>
#include <vector>
#define MAX_THREADS  4
void InvertProc( void * MyID );      // Threads 2 to n: display 
void ShutDown( void );               // Program shutdown 
int     ThreadNr;                    // Number of threads started 
CRITICAL_SECTION cs, cs2;
std::vector<int> _oTempVector;
std::vector<int> _oOutVector;
int OutCounter;
int _tmain(int argc, _TCHAR* argv[])
{     
   ThreadNr = 0;
   OutCounter = 0;
   for ( int i = 0; i < 50000; i++ ) {
      _oTempVector.push_back( i );
      _oOutVector.push_back( 0 );
   }
   InitializeCriticalSection( &cs );   
   InitializeCriticalSection( &cs2 ); 
   std::vector<HANDLE> events;
   for ( ThreadNr = 0; ThreadNr < MAX_THREADS; ThreadNr++ ) {            
      HANDLE handle = (HANDLE)_beginthread( InvertProc, 0, &ThreadNr );      
      events.push_back( handle );
   }
   WaitForMultipleObjects( events.size(), &events[0], true, INFINITE );  
   std::cout << "outvector contains:" << _oOutVector.size() << "elements"; 
   std::cout << 'n'; 
}

void InvertProc( void *pMyID )
{   
   do {
      EnterCriticalSection( &cs ); 
      if ( _oTempVector.size() > 0 ) {
         int iElement = _oTempVector.back();
         _oTempVector.pop_back();
         LeaveCriticalSection( &cs );
         iElement *= -1;
         EnterCriticalSection( &cs2 ); 
         _oOutVector[OutCounter] = iElement; 
         OutCounter++;
         LeaveCriticalSection( &cs2 );
      }
   } while ( _oTempVector.size() > 0 );   
}

您的输出向量不在关键部分内，它应该是一个共享对象。。。。因为如果多个线程同时尝试push_back，您将面临"重写写数据"竞赛！！！！

  EnterCriticalSection( &cs ); 
  if ( _oTempVector.size() > 0 ) {
     int iElement = _oTempVector.back();
     _oTempVector.pop_back();
          iElement *= -1;
     _oOutVector.push_back( iElement );   
     LeaveCriticalSection( &cs );
  }
 } while ( _oTempVector.size() > 0 );

所产生的运行线程将比并发更顺序地运行

要解决这个问题，您必须采取不同的做法：1） 你能解决这个问题吗？每个线程都应该处理输入向量的连续元素2） 如果输出向量一开始是用输入的大小初始化的，那么就可以消除由于push！

每个正在运行的线程将*-1一个给定范围的数字输入，并将结果放在输出向量的特定位置（没有交互）与其他线程，这样您就可以删除锁定

void InvertProc( void *pMyID )
{   
    int threadnum = *((int*)pMyID);
    int chunk = input.size()/THREAD_NUM;
    int start = threadnum*chunk;
    int end = start+chunk;
    for (I = start ; I < end ; ++I)
    {
        output[i] = input[i]*-1;
    }
 }
相关文章：