C++ 多线程应用程序，我做得对吗？

这是在一个数组上执行4个线程，然后将该数组分配给累积计数吗？我相信是的。我知道rand（）不是线程安全的，一旦我知道逻辑是正确的，我将改变这一点

这是一个集合体的几点建议 然后

我知道这不是在实践最佳实践方法，但我只是想让它开始运行

我想我让它正确运行了，不得不将计数器变量a从x改为p，不知道为什么。。。还将fHolder移出for循环

我的fholder总是结果为0，我不知道为什么。我检查了计数器的值

#include <process.h>
#include <windows.h>
#include <iostream>
#include <fstream>
#include <time.h>
//#include <thread>

using namespace std;

void myThread0 (void *dummy );
void myThread1 (void *dummy );
void myThread2 (void *dummy );
void myThread3 (void *dummy );

//only needed for shared variables
//CRITICAL_SECTION cs1,cs2,cs3,cs4; // global

int main()
{

    //InitializeCriticalSection(&cs1);
    //InitializeCriticalSection(&cs2);
    //InitializeCriticalSection(&cs3);
    //InitializeCriticalSection(&cs4);

    ofstream myfile;
    myfile.open ("coinToss.csv");

    int rNum;

    long numRuns;
    long count = 0;
    int divisor = 1;
    float fHolder = 0;
    long counter = 0;
    float percent = 0.0;


    //?
    unsigned threadID;

    //HANDLE hThread;
    HANDLE hThread[4];

    const int size = 100000;

    int array[size];

    srand ( time(NULL) );

    printf ("Runs (uses multiple of 100,000) ");
    cin >> numRuns;

    for (int a = 0; a < numRuns; a++)
     {

            hThread[0] = (HANDLE)_beginthread( myThread0, 0, (void*)(array) );
            hThread[1] = (HANDLE)_beginthread( myThread1, 0, (void*)(array) );
            hThread[2] = (HANDLE)_beginthread( myThread2, 0, (void*)(array) );
            hThread[3] = (HANDLE)_beginthread( myThread3, 0, (void*)(array) );

            //waits for threads to finish before continuing
            WaitForMultipleObjects(4, hThread, TRUE, INFINITE);

            //closes handles I guess?
            CloseHandle( hThread[0] );
            CloseHandle( hThread[1] );
            CloseHandle( hThread[2] );
            CloseHandle( hThread[3] );

        //dump array into calculations
        //average array into fHolder

            for (int p = 0; p < size; p++)
             {
                counter += array[p] == 2 ? 1 : -1;
                //cout << counter << endl;
                //cout << count << endl;
                //cout << p << endl;
                counter = count + counter;

                //divide into an exportable value
                //divides by 1,000,000, because each thread handles 250,000
                //cout << "Value " << x << ": " << array[x] << endl;
            }
            fHolder = counter / size;


        cout << "Final Count: " << counter << endl;
        cout << "fHolder: " << fHolder << endl;
        myfile << fHolder << endl;


    }



}
void myThread0 (void *param)
{
    //EnterCriticalSection(&cs1); //aquire the critical section object

    int *i = (int *)param;

    for (int x = 0; x < 25000; x++)
    {
        i[x] = rand() % 2 + 1;
        //cout << i[x] << endl;
    }
    //LeaveCriticalSection(&cs1); // release the critical section object

}

void myThread1 (void *param)
{
    //EnterCriticalSection(&cs2); //aquire the critical section object

    int *i = (int *)param;

    for (int x = 25000; x < 50000; x++)
    {
        //param[x] = rand() % 2 + 1;
        i[x] = rand() % 2 + 1;
        //cout << i[x] << endl;
    }
    //LeaveCriticalSection(&cs2); // release the critical section object

}

void myThread2 (void *param)
{
    //EnterCriticalSection(&cs3); //aquire the critical section object

    int *i = (int *)param;

    for (int x = 50000; x < 75000; x++)
    {
        i[x] = rand() % 2 + 1;
        //cout << i[x] << endl;
    }
    //LeaveCriticalSection(&cs3); // release the critical section object

}

void myThread3 (void *param)
{
    //EnterCriticalSection(&cs4); //aquire the critical section object

    int *i = (int *)param;

    for (int x = 75000; x < 100000; x++)
    {
        i[x] = rand() % 2 + 1;
        //cout << i[x] << endl;
    }
    //LeaveCriticalSection(&cs4); // release the critical section object

}

#包括
#包括
#包括
#包括
#包括
//#包括
使用名称空间std；
void myThread0（void*dummy）；
void myThread1（void*dummy）；
void myThread2（void*dummy）；
void myThread3（void*dummy）；
//只有共享变量才需要
//临界截面cs1、cs2、cs3、cs4；//全球的
int main（）
{
//初始化关键部分（&cs1）；
//初始化关键部分（&cs2）；
//初始化关键部分（&cs3）；
//初始化关键部分（&cs4）；
流文件；
myfile.open（“cointost.csv”）；
内部；
长纽伦；
长计数=0；
整数除数=1；
浮动fHolder=0；
长计数器=0；
浮动百分比=0.0；
//?
无符号threadID；
//处理hThread；
句柄hThread[4]；
常数int size=100000；
int数组[大小]；
srand（时间（空））；
printf（“运行次数（使用100000的倍数）”；
cin>>numRuns；
对于（int a=0；a
\u beginthread
有问题，您应该改用
\u beginthreadex
。请阅读此新函数的文档以了解如何使用它
hThread是由4个句柄组成的数组，因此在调用
WaitForMultipleObjects
时，应该有4个句柄而不是1个句柄，并且应该有4个调用
CloseHandle
来关闭所有四个句柄
考虑重命名变量ahThread（数组为a）或rghThread（范围为rg）
所有四个线程都在各自的数据块上运行。您的代码在实际使用这些数据之前会故意等待所有四个线程完成。这意味着您不需要四个关键部分中的任何一个。两个线程同时读取和写入某些数据是没有危险的
这些关键部分使用错误。在代码中只有一个输入关键部分的位置是没有意义的，因为CS的目的是防止在CS下的当前代码执行时执行其他代码。在代码中只有一个使用CS1的位置，只有一个使用CS2的位置，依此类推。只需删除它们，因为正如（4）中所解释的，你实际上并不需要它们
标准输出是一个单独的资源，由它自己的内部关键部分保护，并在所有四个线程中使用。因此，所有四个线程都被迫在线同步
难道我看了你的文章两遍，仍然不明白你的问题是什么吗。你能整理你的代码，留下真正重要的内容，并问你的问题吗更清楚的解释？只需对您的代码做一点注释：每个线程都为整个逻辑获取相同的关键部分，这意味着不会有线程并行运行。我不知道您的意图，反正\u beginthread不喜欢多个参数。我必须创建一个结构，然后我不确定它是否会很好，我读到结构在将_beginthread称为void时有问题，但我将尝试它。我在for（int x=0；x