小编inf*_*inf的帖子

阅读boost :: asio的文档,我还不清楚何时需要使用asio :: strand.假设我有一个使用io_service的线程,那么可以安全地在套接字上写入如下吗？

void Connection::write(boost::shared_ptr<string> msg)
{
    _io_service.post(boost::bind(&Connection::_do_write,this,msg));
}

void Connection::_do_write(boost::shared_ptr<string> msg)
{
    if(_write_in_progress)
    {
      _msg_queue.push_back(msg);
    }
    else
    {
      _write_in_progress=true;
      boost::asio::async_write(_socket, boost::asio::buffer(*(msg.get())),
      boost::bind(&Connection::_handle_write,this,
             boost::asio::placeholders::error));
    }
}

void Connection::_handle_write(boost::system::error_code const &error)
{
  if(!error)
  {
    if(!_msg_queue.empty())
    {
          boost::shared_ptr<string> msg=_msg_queue.front();
      _msg_queue.pop_front();
      boost::asio::async_write(_socket, boost::asio::buffer(*(msg.get())),
           boost::bind(&Connection::_handle_write,this,
                   boost::asio::placeholders::error));
        }
    else
    {
      _write_in_progress=false;
    }
  }
}

多个线程调用Connection :: write(..)或者我必须使用asio :: strand吗？

我对boost :: threads很新,我阅读了文档,但是我在实践中应用它时遇到了一些麻烦,也许你可以帮忙吗？首先,我花时间编写了一个自包含的代码清单,演示了两种我无法理解的行为......

该程序允许用户发出3个不同的命令,

• 任务名称]
• 信息
• 放弃

目的是任务将在新线程上启动一些工作,但在执行工作时返回到命令提示符.用户可以使用info命令找出哪些任务已完成,哪些未完成.

我使用双核Win7机器和Visual Studio 2008 Express.

问题1>

发出命令,任务p1 p2 p3,启动3个任务正在运行.这可以通过发布信息来检查.几秒钟后,工作完成,但由于某种原因,完成的标志并不总是在1或2个任务上设置为true.

问题2>

退出程序然后生成以下消息:

Windows在example.exe中触发了断点.这可能是由于堆的损坏,这表示example.exe或它已加载的任何DLL中的错误.这也可能是由于用户在example.exe具有焦点时按下F12.输出窗口可能包含更多诊断信息.

希望您可以重现此行为并提供帮助.

提前致谢.亚历克斯.

    //WARNING: THIS CODE DOES NOT BEHAVE EXACTLY AS INTENDED
#include <iostream>  
#include <string>
#include <sstream>
#include <boost/thread.hpp>  

using namespace std;

class task {
public:
    string mname;
    bool completed;
    void start()
    {
        int a = 0;
        for (int i=0 ; i<10000; i++)
        {
            for (int j=0 ; j<100000; j++)
            {
                a= i*2; …

为什么会这样？

>>> map(numpy.all, range(-2, 3))
[-2, -1, 0, 1, 2]

是有意还是整数只是通过裂缝掉落？

它是否与:

>>> map(numpy.all, [False, True])
[False, True]

我正在Numpy 1.8.0.dev-74b08b3和Python 2.7.3

在Mac OS上,如果我跑clang --version,我得到:

Apple LLVM version 6.0 (clang-600.0.34.4) (based on LLVM 3.5svn)
Target: x86_64-apple-darwin14.0.0
Thread model: posix

由于LLVM官方页面显示当前的LLVM版本为3.5,因此Apple clang版本似乎与开源LLVM不同.输出(based on LLVM 3.5svn)表明我的机器上可能也是3.5.

现在我来到这里,因为我想编译一个C++ 14文件,使用g++ -std=c++14 main.cc.此页面表明此选项应适用于clang 3.5.但是,它仅-std=c++1y适用于clang 3.4或更早版本.

那么什么是LLVM开源版本等同于Apple的版本？它似乎3.5但是为什么它不起作用呢？

当我运行此代码时:

#include <iostream>
#include <thread>
#include <mutex>

std::mutex m;

int main()
{
    std::vector<std::thread> workers;
    for (int i = 0; i < 10; ++i)
    {
        workers.emplace_back([i]
        {
            std::lock_guard<std::mutex> lock(m);
            std::cout << "Hi from thread " << i << std::endl;
        });
    }

    std::for_each(workers.begin(), workers.end(), [] (std::thread& t)
    { t.join(); });
}

我得到输出:

Hi from thread 7
Hi from thread 1
Hi from thread 4
Hi from thread 6
Hi from thread 0
Hi from thread 5
Hi from thread 2 …

我目前正在做一些带有模板化功能的练习.我的任务是编写变换算法的实现.我做了以下这样的工作:

template <class in, class out, class T>
out stransform(in b, in e, out d, T p(const T&)) {
    while (b != e) 
        *d++ = p(*b++);
    return d;
}

与正常变换一样,我必须使用类似的显式类型来调用谓词

stransform(begin(vec1), end(vec1), back_inserter(vec2), predi<double>);

现在,我偶然发现了C++ 11 Lambdas,想要调用我的函数:

stransform(begin(vec1), end(vec1), back_inserter(vec2), [] (double x) ->double {return x * 10;} );

有了这个,我确实得到了一个编译器错误,该类型无法推断出来.这是我不理解的事情,因为我实际上在我的lambda中定义了T类型两次.

我还检查了它正在使用的原始转换函数.然后我检查了那个的实现,它显然是用整个函数的模板类实现的.这是使用模板实现谓词的正确方法吗？

我正在研究一种用C++创建应用程序的架构,以便在不同的内核中同时处理多个输入.每个输入同时在单个核心中处理.核心上的每个进程,相同的过滤器都将通过处理.例如:filter1.apply(),filter2.apply()和filter3.apply().针对4个输入的4个核心说明了这些过程,如下所示:

[core 1]   [core 2]    [core 3]   [core 4]
   |          |            |         |     
   V          V            V         V
  input1     input2      input3     input4
   |          |            |         |    
   V          V            V         V 
 filter1    filter1     filter1    filter1
   |          |            |         |    
   V          V            V         V 
 filter2    filter2     filter2    filter2
   |          |            |         |    
   V          V            V         V 
 filter3    filter3     filter3    filter3
   |          |            |         |    
   V          V            V         V 
 output1   output2      output3    output4

我不知道哪种架构或设计模式适合这种情况.如果您给我一些工件(文档或示例应用程序)以进一步阅读,那将是很棒的.

提前致谢.

我用 C 开发了一个 ARM7 嵌入式系统的应用程序。现在我想用 C++ 编译和链接它，以便使用一些 C++ 特性。为此，我使用mipsel-elf-g++代替mipsel-elf-gcc. 我可以mipsel-elf-g++成功编译我的代码，但在链接步骤中我收到错误：

/opt/mipsel/lib/gcc/mipsel-elf/3.4.6/../../../../mipsel-elf/lib/libc.a(lib_a-abort.o)：在函数```abort': /cygdrive/d/Files/cross/mips/newlib-1.15.0/newlib/libc/stdlib/abort.c:63: undefined reference to_exit' `

/opt/mipsel/lib/gcc/mipsel-elf/3.4.6/../../../../mipsel-elf/lib/libc.a(lib_a-signalr.o)：在函数```_kill_r': /cygdrive/d/Files/cross/mips/newlib-1.15.0/newlib/libc/reent/signalr.c:61: undefined reference tokill中`

collect2: ld 返回 1 个退出状态

搜索了一下这个问题，发现应该实现自己的_exit和kill功能，所以在我的项目中添加了这段代码：

void _exit(int code)
{
    while(1);

}

int _DEFUN (kill, (pid, sig), int pid _AND int sig)
{
    if(pid == __MYPID)
        _exit(sig);

    return 0;
}

通过添加这两个函数，修复了对 `_exit' 错误的未定义引用，但对 `kill' 错误的未定义引用仍然存在。

我应该怎么做才能解决这个问题？

当启动策略设置为创建线程时std::launch::async,cppreference上给出的描述是

启动新线程以异步执行任务

如果我有一些任意的功能

double Foo(double i)
{
    return i * 5.0;
}

我async这样打电话

std::vector<double> values{5.0, 2.3, 7.1, 4.8, 1.5};
std::vector<std::future<double>> answers;
for (double value : values)
{
    answers.push_back(std::async(std::launch::async,
                                 Foo,
                                 value));
}

当我这样打电话时std::accumulate:

double total = std::accumulate(begin(answers),
                               end(answers),
                               0.0,
                               [](double x, std::future<double>& t){return x + t.get();});

什么时候每个线程开始执行？他们一加入就开始了answers吗？或者他们等到他们get被调用？如果是这样,我是否只是强制它们按顺序执行,因为它们get是按执行顺序调用的accumulate？换句话说,我是否只是浪费时间设置这些未来,然后强迫它们同步运行？

注意
该函数Foo只是一些例子,我正在使用的实际函数做了更多工作.

所以,我把这个应用程序作为服务.每个应用程序都是用户特定 因此,对于每个用户,我想启动一个新的docker实例.应该有可能重新启动最后一次停靠的docker实例.所以它也需要持久存储.

我想知道是否有任何库/框架使这更容易？如果这个库是golang库会很棒.

提示1:它不一样,但类似于koding.com等服务为每个用户/用户的项目启动一个单独的容器.