C++ Boost在线程之间抛出异常的代码示例

Question

有人可以通过修改下面的代码,显示一个简单但完整的例子,说明如何使用Boost异常库在线程之间传递异常？

我正在实现的是一个简单的多线程委托模式.

class DelegeeThread
{
public:
  void operator()()
  {
     while(true)
     {
       // Do some work

       if( error )
       {
         // This exception must be caught by DelegatorThread
         throw std::exception("An error happened!");
       }
     }
  }
};

class DelegatorThread
{
public:
  DelegatorThread() : delegeeThread(DelegeeThread()){}  // launches DelegeeThread
  void operator()()
  {
    while( true )
    {
       // Do some work and wait

       // ? What do I put in here to catch the exception thrown by DelegeeThread ?
    }
  }
private:
  tbb::tbb_thread    delegeeThread;
};

Answer 1

我假设您希望委托在单独的线程上异步执行。这是使用 boost 线程和异常的示例：

#include <boost/exception/all.hpp>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <iostream>

class DelegeeThread
{
public:
    void operator()( boost::exception_ptr& excPtr )
    {
        try
        {
            int counter = 0;
            while( true )
            {
                // Do some work

                if( ++counter == 1000000000 )
                {
                    throw boost::enable_current_exception( std::exception( "An error happened!" ) );
                }

            }
        }
        catch( ... )
        {
            // type of exception is preserved
            excPtr = boost::current_exception();
        }
    }
};

class DelegatorThread
{
public:
    DelegatorThread() : 
      delegeeThread( boost::bind( &DelegeeThread::operator(), boost::ref( delegee ), boost::ref( exceptionPtr ) ) )
      {
          // launches DelegeeThread
      }

    void wait()
    {
        // wait for a worker thread to finish
        delegeeThread.join();

        // Check if a worker threw
        if( exceptionPtr )
        {
            // if so, rethrow on the wait() caller thread
            boost::rethrow_exception( exceptionPtr );
        }
    }

private:
    DelegeeThread           delegee;
    boost::thread           delegeeThread;
    boost::exception_ptr    exceptionPtr;
};


int main () 
{
    try
    {
        // asynchronous work starts here
        DelegatorThread dt;

        // do some other work on a main thread...

        dt.wait();

    }
    catch( std::exception& e )
    {
        std::cout << e.what();
    }

    system("pause");
    return 0;
}