So I have written a minimal example that I hope would result more intuitive as a first introduction to this concept.
This post is from April 2012, and it is now obsolete, please follow the link to the updated version I have written on March 2018.
We have a class designed to be used in a multithread context, it has as data member a resource that is meant to be shared, and we have a couple of functions that modify that shared value, and could be called from different threads.
Usually what we do is relying on mutexes and locks to synchronize the access to the shared resource. ASIO provides us the strand class, as a way to serialize the execution of the works posted to it, making unnecessary explicit synchronization. But be aware that this is true only for the functions going to the same strand.
We want to write a piece of code like this:
namespace ba = boost::asio; // ... ba::io_service aios; Printer p(aios, 10); // 1 boost::thread t(std::bind(&ba::io_service::run, &aios)); // 2 aios.run(); // 3 t.join(); // 41. See below for the class Printer definition. In a few words, it is going to post the execution of a couple of its functions on ASIO, both of them acting on the same shared resource.
2. We run a working thread on the ASIO I/O service.
3. Also the main thread is running on ASIO.
4. Wait for the worker completion, than end the execution.
So we have two threads running on ASIO. Let's see now the Printer class private section:
class Printer
{
private:
ba::strand strand_; // 1
int count_; // 2
void print(const char* msg) // 3
{
std::cout << boost::this_thread::get_id() << ' ' << msg << ' ' << count_ << std::endl;
}
void print1() // 4
{
if(count_ > 0)
{
print("print one");
--count_;
strand_.post(std::bind(&Printer::print1, this));
}
}
// ...
};
1. We are going to operate on a Boost Asio strand object.2. This is our shared resource, a simple integer.
3. A utility function that dumps to standard output console the current thread ID, a user message, and the shared resource.
4. Client function for (3), if the shared resource count_ is not zero, it calls (3), than decreases count_ and post through the strand a new execution of this function. There is another private function, print2(), that is exactly like print1(), it just logs a different message.
Since we are in a multithread context, these function should look suspicious. No mutex/lock? No protection to the access of count_? And, being cout an implicitly shared resource, we are risking to get a garbled output too.
Well, these are no issues, since we are using a strand.
But let's see the Printer ctor:
Printer(ba::io_service& aios, int count) : strand_(aios), count_(count) // 1
{
strand_.post(std::bind(&Printer::print1, this)); // 2
strand_.post(std::bind(&Printer::print2, this));
}
1. Pay attention to how the private ASIO strand object is constructed from the I/O service.2. We prepare the first runs, posting on the strand the execution of the private functions.
What happens is that all the works posted on the strand are sequentially executed. Meaning that a new work starts only after the previous one has completed. There is no overlapping, no concurrency, so no need of locking. Since we have two threads available, ASIO will choose which one to use for each work execution. We have no guarantee on which thread is executed what.
We don't have the troubles associated with multithreading, but we don't have some of its advantages either. Namely, when running on a multicore/multiprocessor machine, a strand won't use all the available processing power for its job.
The full C++ source code for this example is on github.
