Question

我对CS有一些了解，但我是初学程序员，当然没有并行计算经验。

我写的财务模拟遍历了60天，每天有大约1,000,000行数据存储在向量中。每一天都是只读的，并在主循环中独立处理，所以我认为一些并行化可以真正加快速度。不幸的是，我的所有线程似乎都是按顺序运行而没有改善执行时间。

我复制了我在这个网站上看到的一些线程示例，并确实看到了一些并行化，但是当我添加共享数据时，这消失了，并且线程按顺序运行。

我原来的程序很大，所以我试着提炼下面的代码。

正如您所看到的，第一列正在完全处理中。在下一个之前。输出不应该在线程之间有一些交错吗？至少，下一个线程应该开始：在前一个线程结束之前？它是一个缓存的东西吗？实现这一目标应该将处理时间缩短75％，但实际上需要更长的时间。

在我原来的程序中，我实现了一些非常简单的锁定，但是我没有在这里包含它，因为没有它就会出现问题。

非常感谢任何帮助。

//ThreadTest.h

#include <string>
#include <fstream>
#include <vector>
#include <thread>
#include <mutex>
#include <windows.h>
#include <time.h>

#pragma once

using namespace std;

extern mutex test_lock;

class Storage {
public:
    Storage(int rows, int cols) {
        data.resize(cols);
        for (vector<vector<string>>::iterator i = data.begin(); i != data.end(); i++) {
            i->resize(rows);
        }
        for (vector<vector<string>>::iterator i = data.begin(); i != data.end(); i++) {
            for (vector<string>::iterator j = i->begin(); j != i->end(); j++) {
                *j = to_string(i - data.begin()) + " " + to_string(j - i->begin());
            }
        }
    }

    vector<vector<string>> data;
};

class ThreadTest {
public:
    ThreadTest() {
        fout.open("TESTOUT.txt");
    }

    ofstream fout;
    void storage_work(const vector<string>& column);
    void loop(const vector<vector<string>>& data);
};

//ThreadTest.cpp
#include "ThreadTest.h"

mutex test_lock;

void ThreadTest::storage_work(const vector<string>& column)
{
    fout << "Begin: \n";
    for (vector<string>::const_iterator i = column.begin(); i != column.end(); i++) {
        if ((i - column.begin()) % 100000 == 0) fout << ":" << *i << " \n";
    }
    fout << "End: \n";
}

void ThreadTest::loop(const vector<vector<string>>& data)
{
    vector<thread> thread_list;

    for (vector<vector<string>>::const_iterator i = data.begin(); i != data.end(); i++) {
        thread_list.emplace_back(&ThreadTest::storage_work, this, *i);
    }
    fout << "thread_list.size() : " << thread_list.size() << endl;
    for (vector<thread>::iterator i = thread_list.begin(); i != thread_list.end(); i++) {
        i->join();
    }
}

//Source.cpp
#include "ThreadTest.h"

using namespace std;

int main()
{
    ThreadTest t;
    Storage s(1000000, 10);
    t.loop(s.data);
}

//TESTOUT.txt
Begin: 
:0 0 
:0 100000 
:0 200000 
:0 300000 
:0 400000 
:0 500000 
:0 600000 
:0 700000 
:0 800000 
:0 900000 
End: 
Begin: 
:1 0 
:1 100000 
:1 200000 
:1 300000 
:1 400000 
:1 500000 
:1 600000 
:1 700000 
:1 800000 
:1 900000 
End: 
Begin: 
:2 0 
:2 100000 
:2 200000 
:2 300000 
:2 400000 
:2 500000 
:2 600000 
:2 700000 
:2 800000 
:2 900000 
End: 
Begin: 
:3 0 
:3 100000 
:3 200000 
:3 300000 
:3 400000 
:3 500000 
:3 600000 
:3 700000 
:3 800000 
:3 900000 
End: 
Begin: 
:4 0 
:4 100000 
:4 200000 
:4 300000 
:4 400000 
:4 500000 
:4 600000 
:4 700000 
:4 800000 
:4 900000 
End: 
Begin: 
:5 0 
:5 100000 
:5 200000 
:5 300000 
:5 400000 
:5 500000 
:5 600000 
:5 700000 
:5 800000 
:5 900000 
End: 
Begin: 
:6 0 
:6 100000 
:6 200000 
:6 300000 
:6 400000 
:6 500000 
:6 600000 
:6 700000 
:6 800000 
:6 900000 
End: 
Begin: 
:7 0 
:7 100000 
:7 200000 
:7 300000 
:7 400000 
:7 500000 
:7 600000 
:7 700000 
:7 800000 
:7 900000 
End: 
Begin: 
:8 0 
:8 100000 
:8 200000 
:8 300000 
:8 400000 
:8 500000 
:8 600000 
:8 700000 
:8 800000 
:8 900000 
End: 
Begin: 
:9 0 
thread_list.size() : 10
:9 100000 
:9 200000 
:9 300000 
:9 400000 
:9 500000 
:9 600000 
:9 700000 
:9 800000 
:9 900000 
End:

线程似乎与共享只读数据同时运行

0 个答案: