在不同的线程中调用std :: function

Question

I'm working in a c++ framework, mostly written before c++11, that allows us to fire events from a thread to a different thread (assuming that the receiving thread is running an event queue, so it's mainly used to fire events to the main UI thread from a helper thread).

Currently, the code to accomplish this is very verbose - it requires us to define two classes:

1. An event class that contains any information we want to transfer.
2. A listener class that handles the event in the receiving thread.

We've recently moved to c++11/14 and have been working on updating a lot of our code to use smart pointers, standard containers, and lambdas. I'd like to write a generic class that allows me to send a lambda to be run in a different thread. Something like:

mBoundary = make_unique<ThreadBoundary>( []( int value ) { doSomething( value ); } ); 
mBoundary->callInMainThread( 47 );

ThreadBoundary boundary2( []( std::string value ) { displayString( value ); } );
boundary2.callInMainThreadWait( "Show this string to the user" );

As an initial attempt, I've currently got this working with a lambda that doesn't take any parameters, built on top of the current framework functionality (omitting error checking, cleanup, etc):

class ThreadBoundary
{
public:
    ThreadBoundary( std::function<void()> function ):mFunction( function )
    {
        mListener = make_shared<ThreadBoundaryListener>();
        cApplication::addThreadBoundaryListener( mListener );
    }

    void callInMainThread()
    {
        cApplication::fireEventInMainThread( new ThreadBoundaryEvent( mFunction ) );
    }

    class ThreadBoundaryEvent:public FrameworkThreadBoundaryEvent
    {
    public:
        ThreadBoundaryEvent( std::function<void()> function )
        {
            mFunction = function;
        }

        void call() { mFunction(); }

    private:
        std::function<void()> mFunction;
    };

    class ThreadBoundaryListener:public FrameworkThreadBoundaryListener
    {
    public:
        ThreadBoundaryListener() {}

        void handleEvent( const FrameworkThreadBoundaryEvent* event )
        {
            dynamic_cast<const ThreadBoundaryEvent*>( event )->call();
        }
    };

private:
    shared_ptr<ThreadBoundaryListener> mListener;
    std::function<void()> mFunction;
};

This allows me to fire "one-off" events to the main thread, however, without being able to send along parameters it's functionality is pretty limited.

I'd like to make this class use variadic templates so that I can pass anything to the callInMainThread function. However, I haven't been able to figure out how to store the parameter pack in the event and pass it along to the function inside call() . So my questions are:

1. Is it possible to store a parameter pack and later pass it to a std::function?
2. Is there a better way to do this in c++11/14 that doesn't require a huge redesign? Our framework is currently wrapping OS functionality to accomplish this (ie on Windows it uses SendMessage vs performSelectorOnMainThread in OS X).

Answer 1

Instead of separating the interface construction from the invocation, use the power of the lambdas to capture arguments into the function object itself (a closure) so that every invocation is the same. Don't have the basic thread communication object encapsulate a function type. Instead, pass the entire function as you call. Go for this interface:

threadBoundary.callInMainThread([value](){doSomething(value);});

If everything you pass is a function object that takes no parameters, it's easy to pass and easy to call. Capture anything you need to pass.

For some interface and implementation ideas, look at how boost::asio implements its io_service , which allows you to post function calls to other threads just like this.

Answer 2

A nullary function call is easier to send accross a thread boundary. And it is easy to capture the arguments you want to pass into a lambda capture list.

I'd embrace that.

However, you can write code to turn a non-nullary function call into a nullary one pretty easily. If you want to "freeze" the function call without the arguments, the signature must also be frozen.

tempate<class Sig>
struct freeze_function;
tempate<class R, class...Args>
struct freeze_function<R(Args...)> {
  std::function< R(Args...) > to_freeze;
  freeze_function() = default;
  freeze_function( freeze_function&& ) = default;
  freeze_function( freeze_function const& ) = default;
  freeze_function& operator=( freeze_function&& ) = default;
  freeze_function& operator=( freeze_function const& ) = default;
  freeze_function( std::function< void(Args...) > f ):to_freeze(std::move(f)) {}

  std::function<R()> operator()( Args... args ) const {
    return [=, frozen=this->to_freeze]->R{
      return frozen( args... );
    };
  }
};

A freeze_function<void(int)> can be constructed from a lambda taking an int . You can then pass it an int and it returns a std::function<void()> with that int bound.

But I think this isn't required.

(Extra work required to get optimal efficiency out of freeze_function ; it needlessly copies args... . I'd toss the args... into a tuple then unpack them within the lambda, maybe using the equivalent of std::apply from C++17.)

This can be either baked into the ThreadBoundary by adding a signature (making it a template), or can be used to store your unrealized function calls somewhere and freezing them immediately prior to passing the resulting std::function<void()> to ThreadBoundary .