由于以下原因，我已经开始研究创建和运行线程所花费的时间。我这样做的方法是，我发现此过程需要10个线程大约26毫秒，这比它应该的要长得多-至少从我的理解来看。
简短的背景：
我正在开发使用寻路的游戏。添加更多实体后，有必要使该过程并行化。
我希望它尽可能易读，因此我创建了一个ParallelTask类，该类包含一个线程std :: function（应该由踏步执行），一个互斥体以保护某些写操作，并且布尔值已完成。线程完成执行后，将其设置为true。
我是多线程技术的新手，所以我不知道这是不是一个好的开始，但是我总是感到困惑，为什么执行起来需要这么长时间。
我已经编写了下面的代码来隔离问题。
int main()
{
std::map<int, std::unique_ptr<ParallelTask>> parallelTaskDictionary;
auto start = std::chrono::system_clock::now();
for (size_t i = 0; i < 10; i++)
{
parallelTaskDictionary.emplace(i, std::make_unique<ParallelTask>());
parallelTaskDictionary[i]->Execute();
}
auto end = std::chrono::system_clock::now();
auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
std::cout << elapsed.count() << std::endl;
parallelTaskDictionary.clear();
return 0;
}
class ParallelTask
{
public:
ParallelTask();
// Join the treads
~ParallelTask();
public:
inline std::vector<int> GetPath() const { return path; }
void Execute();
private:
std::thread thread;
mutable std::mutex mutex;
std::function<void()> threadFunction;
bool completed;
std::vector<int> path;
};
ParallelTask::ParallelTask()
{
threadFunction = [this]() {
{
std::lock_guard<std::mutex> lock(mutex);
this->completed = true;
}
};
}
ParallelTask::~ParallelTask()
{
if (thread.joinable())
thread.join();
}
void ParallelTask::Execute()
{
this->completed = false;
// Launch the thread
this->thread = std::thread(threadFunction);
}
运行这段代码可以给我25到26毫秒的执行时间。由于这是要用于游戏中，因此它当然是不可接受的。
如前所述，我不理解为什么，尤其是因为threadFunction本身确实做到了这一点。如果您想知道，我什至删除了互斥锁，它实际上给了我相同的结果，因此这里肯定还有其他事情发生。 （根据我的研究，创建线程的时间不应超过几微秒，但也许我只是错了^^）
PS：哦，是的，虽然我们在开会，但我仍然不太了解谁应该拥有互斥量。 （是否有一个全局对象或每个对象一个...）？？？
最佳答案
如果只想测量执行时间，我认为您应该仅在工作完成的地方将now和end语句放在threadFunction内，如下面的代码所示。
#include <map>
#include <iostream>
#include <memory>
#include <chrono>
#include <vector>
#include <thread>
#include <mutex>
#include <functional>
class ParallelTask
{
public:
ParallelTask();
// Join the treads
~ParallelTask();
public:
inline std::vector<int> GetPath() const { return path; }
void Execute();
private:
std::thread thread;
mutable std::mutex mutex;
std::function<void()> threadFunction;
bool completed;
std::vector<int> path;
};
ParallelTask::ParallelTask()
{
threadFunction = [this]() {
{
auto start = std::chrono::system_clock::now();
std::lock_guard<std::mutex> lock(mutex);
this->completed = true;
auto end = std::chrono::system_clock::now();
auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
std::cout << "elapsed time" << elapsed.count() << std::endl;
}
};
}
ParallelTask::~ParallelTask()
{
if (thread.joinable())
thread.join();
}
void ParallelTask::Execute()
{
this->completed = false;
// Launch the thread
this->thread = std::thread(threadFunction);
}
int main()
{
std::map<int, std::unique_ptr<ParallelTask>> parallelTaskDictionary;
for (size_t i = 0; i < 10; i++)
{
parallelTaskDictionary.emplace(i, std::make_unique<ParallelTask>());
parallelTaskDictionary[i]->Execute();
}
parallelTaskDictionary.clear();
return 0;
}
输出：
elapsed time1
elapsed time0
elapsed time0
elapsed time0
elapsed time0
elapsed time0elapsed time
0
elapsed time0
elapsed time0
elapsed time0
因为我们排除了启动线程所需的时间。
就像进行完整性检查一样，如果您真的想查看实际工作的效果，则可以添加，
using namespace std::chrono_literals;
std::this_thread::sleep_for(2s);
到您的
threadFunction，使其看起来像这样ParallelTask::ParallelTask()
{
threadFunction = [this]() {
{
auto start = std::chrono::system_clock::now();
std::lock_guard<std::mutex> lock(mutex);
this->completed = true;
using namespace std::chrono_literals;
std::this_thread::sleep_for(2s);
auto end = std::chrono::system_clock::now();
auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
std::cout << "elapsed time" << elapsed.count() << std::endl;
}
};
}
输出将是
elapsed time2000061
elapsed timeelapsed time2000103
elapsed timeelapsed time20000222000061
elapsed time2000050
2000072
elapsed time2000061
elapsed time200012