是否可以使用boost的线程创建线程池？我正在寻找所有的升级库,我找不到线程池管理器(或类似的东西)......有没有办法做到这一点？

TNX!

我遇到了这个问题并阅读它最终让我看到了boost::detail::spinlock_pool.

其目的boost::detail::spinlock_pool是spinlock通过在shared_ptrs地址上进行散列选择s 数组来减少对全局自旋锁的潜在争用.这似乎是一个合理的解决方案,但目前(Boost v1.49)版本的实现似乎存在问题.

spinlock_pool管理静态分配的41个spinlock实例的数组.看来,sizeof(spinlock)==4对于我所看到的平台 - 这意味着,例如x64与64字节spinlock的高速缓存行,每个高速缓存行将有16 秒.

即整个阵列跨越所有2 1/2缓存线.

也就是说,有一个随机螺旋锁错误共享的可能性为40%.

......首先几乎完全打败了游泳池的目的.

我的分析是正确的还是我遗漏了一些重要的东西？

更新: 我终于写了一个小的基准程序:

#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>
#include <boost/timer.hpp>
#include <iostream>
#include <vector>
#include <stdlib.h>

using namespace std;

enum { BufferSize = 1<<24,  SLsPerCacheLine = 1 };

int          ibuffer[BufferSize];

using boost::detail::spinlock;
size_t nslp = 41;
spinlock* pslp = 0;

spinlock& getSpinlock(size_t h)
{
  return pslp[ (h%nslp) * SLsPerCacheLine ];
}


void …

我正在尝试使用clang ++在Windows上使用Boost.Thread.

在包含boost/thread.hpp时,我遇到以下编译错误:

使用-DBOOST_USE_WINDOWS_H:

In file included from D:/env/boost/boost_1_58_0\boost/thread.hpp:13:
In file included from D:/env/boost/boost_1_58_0\boost/thread/thread.hpp:12:
In file included from D:/env/boost/boost_1_58_0\boost/thread/thread_only.hpp:15:
In file included from D:/env/boost/boost_1_58_0\boost/thread/win32/thread_data.hpp:11:
D:/env/boost/boost_1_58_0\boost/thread/win32/thread_primitives.hpp:223:67: error: conflicting types for 'GetProcAddress'
                __declspec(dllimport) detail::farproc_t __stdcall GetProcAddress(void *, const char *);
                                                                  ^
/mingw/include\winbase.h:1675:27: note: previous declaration is here
WINBASEAPI FARPROC WINAPI GetProcAddress(HINSTANCE,LPCSTR);
                          ^
In file included from D:/env/boost/boost_1_58_0\boost/thread/thread_only.hpp:15:
In file included from D:/env/boost/boost_1_58_0\boost/thread/win32/thread_data.hpp:11:
D:/env/boost/boost_1_58_0\boost/thread/win32/thread_primitives.hpp:223:67: warning: redeclaration of 'GetProcAddress' should not add 'dllimport' attribute [-Wdll-attribute-on-redeclaration]
                __declspec(dllimport) detail::farproc_t __stdcall GetProcAddress(void *, const char *);
                                                                  ^ …

我最近意识到线程本地存储在某些平台上是有限的.例如,C++库boost :: thread read的文档:

"注意:可以创建的特定于线程的存储对象的数量存在特定于实现的限制,并且此限制可能很小."

我一直在寻找尝试找出不同平台的限制,但我找不到权威表.如果您正在编写使用TLS的跨平台应用程序,这是一个重要问题.Linux是我找到信息的唯一平台,以Ingo Monar补丁的形式在2002年发送到内核列表添加TLS支持,他提到"TLS区域的数量是无限的,并且没有相关的额外分配开销支持TLS." 如果在2009年仍然如此(是吗？)非常漂亮.

但是今天Linux怎么样？OS X？视窗？的Solaris？嵌入式操作系统？对于在多种体系结构上运行的操作系统,它是否因架构而异？

编辑:如果您对可能存在限制的原因感到好奇,请考虑预先分配线程本地存储的空间,因此您将在每个线程上支付费用.面对很多线程,即使是少量也是一个问题.

似乎Boost的shared_mutex不是递归的..反正这有什么问题吗？(没有重新实现整个东西)

考虑以下C++成员函数:

 size_t size() const
 {
    boost::lock_guard<boost::mutex> lock(m_mutex);
    return m_size;
 }

这里的目的不是同步对私有成员变量的访问m_size,而只是为了确保调用者收到m_size的有效值.目标是防止函数m_size在某些其他线程正在修改的同时返回m_size.

但调用此功能是否涉及任何潜在的竞争条件？我不确定这里的RAII风格锁是否足以抵御竞争条件.假设在将函数的返回值压入堆栈之前调用了锁的析构函数？

我是否需要执行以下操作以确保线程安全？

 size_t size() const
 {
    size_t ret;

    {
      boost::lock_guard<boost::mutex> lock(m_mutex);
      ret = m_size;
    }

    return ret;
 }

我正在使用8核处理器,并使用Boost线程来运行大型程序.从逻辑上讲,程序可以分成组,每个组由一个线程运行.在每个组中,一些类总共调用"new"运算符10000次.Rational Quantify表明,"新"内存分配占用了程序运行时的最大处理时间,并且正在减慢整个程序的速度.

我可以加快系统速度的一种方法是在每个"组"中使用线程,这样10000个内存分配可以并行发生.

我不清楚如何在这里管理内存分配.OS调度程序是否真的能够并行分配内存？

有人有一个如何最容易使用boost :: condition :: timed_wait的例子吗？有一些线程的话题在这里,这里和这里,但没有配备工作的例子.并且提升文档通常非常稀疏.

执行此浮点计算时boost::thread,它会产生与std::thread在主线程中或主线程中执行时不同的结果.

void print_number()
{
    double a = 5.66;
    double b = 0.0000001;
    double c = 500.4444;
    double d = 0.13423;
    double v = std::sin(d) * std::exp(0.4 * a + b) / std::pow(c, 2.3);

    printf("%llX\n%0.25f\n", *reinterpret_cast<unsigned long long*>(&v), v);
}

这似乎是因为boost::thread默认情况下使用53位内部精度进行浮点数学运算,而主线程使用的是64位精度.如果在创建_fpreset()后重置FPU单元的状态boost::thread,则结果与主线程中的结果相同.

我正在使用Embarcadero C++ Builder 10.1(编译器bcc32c版本3.3.1)和Boost 1.55.0.我的环境是Windows 7,我正在构建32位Windows目标.

工作范例:

#include <tchar.h>
#include <thread>
#include <boost/thread.hpp>
#include <cstdio>
#include <cmath>
#include <cfloat>

namespace boost { void tss_cleanup_implemented() {} }

void print_number()
{
    double …

这些天我正在阅读pdf Designing MT程序.它解释了在该对象超出范围之前,用户必须在C++ 0x中显式调用detach()类的std::thread对象.如果你不打电话,std::terminate()它将被调用,应用程序将死亡.

我通常boost::thread在C++中使用线程.如果我错了,请纠正我但是boost::thread当一个对象超出范围时会自动分离.

在我看来,提升方法遵循RAII原则而标准没有.

你知道这有什么特别的原因吗？