# SoftBank Robotics documentation What's new in NAOqi 2.8?

# Asynchronous operations

## Introduction

libqi provides a threadpool for doing small asynchronous operations. Note that blocking in these threads impacts the whole system as a non-working thread will prevent other work from being scheduled.

## With C++ functions

You can push a task to be executed asynchronously from a simple C++ function. It is also possible to specify a delay for the task.

    #include <qi/application.hpp>
    #include <qi/eventloop.hpp>

    void doSomething(int value) {
      std::cout << "value is " << value << std::endl;
    }

    int main(int argc, char* argv[]) {
      qi::Application app(argc, argv);

      // run as soon as possible
      qi::Future<void> future = qi::async(boost::bind(doSomething, 42));
      // run in 2 seconds
      qi::Future<void> future2 = qi::async(boost::bind(doSomething, 42), 2000000);

      // do stuff...

      future.wait();
      future2.wait();

      return 0;
    }

If your function should be called periodically, use `qi::PeriodicTask`.

It is also possible to cancel the execution of a task if it hasn’t started yet:

    qi::Future<void> future = qi::async(boost::bind(doSomething, 42), 2000000);

    future.cancel();

    // doSomething will never be called

## With a qi::AnyObject

To use an AnyObject asynchronously, the `async()` method must be used.

    qi::AnyObject motion = session.service("ALMotion");
    qi::Future<void> moveOp = motion.async("moveTo", 1, 0, 0);
    // Wait for operation to terminate.
    moveOp.wait();

There is another way of doing async with AnyObjects:

    tts.post("say", "Yes!");

`post()` does not return a future, it just posts a call and discards the return value. This is close to calling `async()` but is a bit faster (and spare a message when using remote sessions) because no future is created and the return value is discarded very early. Use it whenever you can when you don’t need the future from `async`.

## Using the returned future

Look at the `qi::Future` for more complete documentation, but here is what you most definitely need to know:

- If the method throws an exception, it is stored in the Future, and can be accessed using error().
- Use wait() to wait for the future to complete. It can accept a timeout duration as argument, and will return the state of the future.
- Use value() and error() to get the stored value or error.
- You can register a callback to be notified when the future finishes with qi::Future::connect().

## With a qi::Future

The callbacks connected to the `qi::Future` will also be called from the threadpool.

    void callback() {
      std::cout << "I'm called from a thread" << std::endl;
    }

    qi::Promise<void> promise;
    qi::Future<void> future = promise.future();
    future.connect(callback);
    promise.setValue(0);

Glossary Site map Index Support Contact Legal Notices