Functor and boost::thread

We have just seen how to create a boost::thread object associated to a free function, so to run it in a different thread.

I have already written a post on using functor instead. In that case I was working on Windows and VC++, but the code didn't need to be changed at all to run on Linux and g++.

Actually, after testing that no change was required, I did change it a bit, to comply with a slightly different code-style and, to introduce some thrill, adding a short sleep after any write.

Here is the new version:

#include <iostream>
#include <boost/thread.hpp>

namespace
{
  class Count
  {
    static boost::mutex mio_;
    const int multi_;
  public:
    Count(const int multi) : multi_(multi) { }

    void operator()()
    {
      for(int i = 0; i < 10; ++i)
      {
        {
          boost::lock_guard<boost::mutex> lock(mio_);
          std::cout << "Thread " << boost::this_thread::get_id()
            << " is looping: " << i*multi_ << std::endl;
        }
        boost::this_thread::sleep(boost::posix_time::millisec(50));
      }
    }
  };

  boost::mutex Count::mio_;
}

void mt02()
{
  std::cout << "Main thread " << boost::this_thread::get_id() << std::endl;
  boost::thread t1(Count(1));
  boost::thread t2(Count(-1));
  t1.join();
  t2.join();
  std::cout << "Back to the main thread " << std::endl; 
}

As already said in the original post, there is no real need for a functor for such a limited functionality, when a function could do fine. The only nuisance was on the parameter binding, but since a call to bind is done in the boost::thread constructor when required, there is no reason to prefer a functor in such a simple case.

Here is the new version of the code - also in this case the slight changes were not due to the change of the development platform:

#include <iostream>
#include <boost/thread.hpp>

using namespace std;

namespace
{
  boost::mutex mio;

  void counter(const int multi)
  {
    for(int i = 0; i < 10; ++i)
    {
      boost::this_thread::sleep(boost::posix_time::millisec(20)); // 1.
      {
        boost::lock_guard<boost::mutex> lock(mio);
        cout << boost::this_thread::get_id() << ": " << multi * i << endl;
      }
    }
  }
}

void mt03()
{
//  boost::thread t1(boost::bind(&myCount, 1));
//  boost::thread t2(boost::bind(&myCount, -1)); // 2.
  boost::thread t1(&counter, 1);
  boost::thread t2(&counter, -1);

  t1.join();
  t2.join();
}

1. Just to change things a bit, here the sleep is before writing.
2. We could have written the binding explicitly, but it is not required.