相关疑难解决方法(0)

它与这个问题松散相关:std :: thread是否在C++ 11中汇集？.虽然问题不同,但意图是一样的:

问题1:使用您自己的(或第三方库)线程池以避免昂贵的线程创建仍然有意义吗？

另一个问题的结论是你不能依赖于std::thread汇集(可能或可能不是).但是,std::async(launch::async)似乎有更高的机会被汇集.

它不认为它是由标准强制,但恕我直言,如果线程创建缓慢,我会期望所有好的C++ 11实现都会使用线程池.只有在创建新线程成本低廉的平台上,我才会期望它们总是产生一个新线程.

问题2:这正是我的想法,但我没有事实证明这一点.我很可能会弄错.这是一个有根据的猜测吗？

最后,在这里我提供了一些示例代码,首先展示了我认为线程创建如何表达async(launch::async):

例1:

 thread t([]{ f(); });
 // ...
 t.join();

变

 auto future = async(launch::async, []{ f(); });
 // ...
 future.wait();

示例2:消防和遗忘线程

 thread([]{ f(); }).detach();

变

 // a bit clumsy...
 auto dummy = async(launch::async, []{ f(); });

 // ... but I hope soon it can be simplified to
 async(launch::async, []{ f(); });

问题3:您希望async版本的thread版本？

其余的不再是问题的一部分,只是为了澄清:

为什么必须将返回值赋给虚拟变量？

不幸的是,当前的C++ 11标准强制您捕获返回值std::async,否则执行析构函数,直到操作终止为止.有人认为这是标准中的一个错误(例如,Herb Sutter). …

什么是C++在生产代码中使用的线程池的良好开源实现(类似于boost)？

请提供您自己的示例代码或示例代码使用的链接.

在C++ 03中,我使用pthread和自建的线程池,它总是保持几个线程运行(因为pthread_create速度很慢),这样我就可以在不考虑性能问题的情况下为小任务启动线程.

现在,在C++ 11中我们有std::thread.我想标准没有说明具体的实现,所以我的问题是标准的库实现.他们是否通常选择合并方法来构造std::threads是便宜的(例如不调用pthread_createposix),或者std::thread只是一个包装器？

换句话说,是否仍然在C++ 11中推荐一个线程池,或者我应该只std::thread在需要时创建一个并将性能提升到标准库？

我有一个程序,其函数将指针作为arg和main.主要是创建n个线程,每个线程根据传递的内容在不同的内存区域运行arg.然后连接线程,主要在区域之间执行一些数据混合,并创建n个新线程,这些线程执行与旧线程相同的操作.

为了改进程序,我想保持线程活着,消除创建它们所需的长时间.线程应在主要工作时休眠,并在必须再次出现时通知.同样,主要应该在线程工作时等待,就像连接一样.

我无法最终实现这一点,总是陷入僵局.

简单的基线代码,任何有关如何修改它的提示将非常感激

#include <thread>
#include <climits>

...

void myfunc(void * p) {
  do_something(p);
}

int main(){
  void * myp[n_threads] {a_location, another_location,...};
  std::thread mythread[n_threads];
  for (unsigned long int j=0; j < ULONG_MAX; j++) {
    for (unsigned int i=0; i < n_threads; i++) {
      mythread[i] = std::thread(myfunc, myp[i]);
    }
    for (unsigned int i=0; i < n_threads; i++) {
      mythread[i].join();
    }
    mix_data(myp); 
  }
  return 0;
}

最近，我一直在寻找一个用于线程并发任务的库。理想情况下，是一个在线程上调用函数的简单接口。任何时候都有 n 个线程，有些线程完成得比其他线程快，并且到达的时间不同。

首先我在尝试 Rx，它在 C++ 中很棒。我还研究了 Blocks 和 TBB，但它们都依赖于平台。对于我的原型，我需要保持平台独立，因为我们还不知道它将在什么上运行，并且可以在做出决定时进行更改。

C++11 有很多关于线程和并发的东西，我发现了很多类似线程池的例子。

https://github.com/bilash/threadpool

类似的项目对 std::thread 和 std::mutex 使用相同的 lambda 表达式。

这看起来非常适合我的需要。有一些问题。池以定义数量的线程启动，任务将排队，直到线程空闲。

如何添加新线程？删除过期的线程？（。加入（）？？）

显然，这对于已知数量的线程要容易得多，因为它们可以在 ctor 中初始化，然后在 dtor 中 join()。

有 C++ 并发经验的人在这里有什么提示或指示吗？

我一直在 OpenMP 中调用它

#pragma omp parallel for num_threads(totalThreads)
for(unsigned i=0; i<totalThreads; i++)
{
workOnTheseEdges(startIndex[i], endIndex[i]);
}

这在 C++11 std::threads 中（我相信这些只是 pthreads）

vector<thread> threads;
for(unsigned i=0; i<totalThreads; i++)
{
threads.push_back(thread(workOnTheseEdges,startIndex[i], endIndex[i])); 
}
for (auto& thread : threads)
{
 thread.join();
}

但是，OpenMP 实现的速度是原来的 2 倍——更快！我本来期望 C++11 线程更快，因为它们更底层。注意：上面的代码不仅被调用一次，而且可能在循环中被调用 10,000 次，所以也许这与它有关？

编辑：为了澄清，在实践中，我要么使用 OpenMP 要么使用 C++11 版本——而不是同时使用两者。当我使用 OpenMP 代码时，需要 45 秒，当我使用 C++11 时，需要 100 秒。

我想要完成这样的事情:

thread t; // create/initialize thread
t.launch(); // launch thread.
t.wait(); // wait
t.launch(); // relaunch the same thread

如何使用boost线程来实现这样的东西？本质上,我需要持久的重新启动线程.

我想避免工作队列,因为在我的情况下实现有点困难

谢谢

我正在使用C++ 11和stl线程编写线程安全队列.WaitAndPop方法目前如下所示.我希望能够将一些内容传递给WaitAndPop,以指示调用线程是否已被要求停止.WaitAndPop应该返回true,如果它等待并返回队列的一个元素,如果调用线程被停止,它应该返回false.

    bool WaitAndPop(T& value, std::condition_variable callingThreadStopRequested)
    {
        std::unique_lock<std::mutex> lock(mutex);
        while( queuedTasks.empty() )
        {
            queuedTasksCondition.wait(lock);
        }

        value = queue.front();
        queue.pop_front();
        return true;
    }

是否可以编写这样的代码？我已经习惯了Win32 WaitForMultipleObjects,但找不到适合这种情况的替代方案.

谢谢.

我已经看到了这个相关的问题,但它并没有真正回答这个问题.在linux上学习线程

对于大多数错误,我经常会知道我需要朝哪个方向前进,但在这里我不知道.

那么让我们从断点本身开始:

使用线程库的任何交互都是相对较少的,这里是所有这些:包含:

#include <thread>

用法:

void evolve(double* bestN, double* bestP, double* bestM, double* bestQ, double* bestWinConstant) {

    std::thread threadArray[threadAmount];

    for (int i = 0; i < 100000; i++) {
        for (int t = 0; t < threadAmount; t++) {
            if (gameArrayInUse[t] == 0) {
                copyArray(gameArray[t], startArray);
                gameArrayInUse[t] = 1;
                threadArray[t] = std::thread(playGames, i, t);
                std::cout << "------------New Thread Spawned, No: " << t << std::endl;
                break;
            }
            if (t == threadAmount - 1) {
                t = -1;
            }
        } …