Boost thread_specific_ptr

Nell'articolo di Bill Kempf su Dr.Dobb's che fa da introduzione alla libreria thread di boost si parla anche della possibilità di allocare memoria specifica ad un thread usando il supporto messo a disposizione dalla libreria boost thread.

In termini di prestazioni, usare la "thread local storage" o "thread specific storage", non é considerato in genere una idea molto brillante. Ma ci sono alcuni casi in cui questa risulta essere la soluzione più ragionevole.

La libreria boost thread mette a disposizione uno smart pointer, boost::thread_specific_ptr, che viene inizializzato a NULL della cui distruzione si fa carico la libreria stessa.

L'utilizzo di questo smart pointer viene mostrato nell'esempio a seguire:

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

using namespace std;

namespace {
  boost::thread_specific_ptr<int> ptr;
  boost::mutex mio;

  class Count
  {
  private:
    int step;

  public:
    Count(int step) : step(step) { }

    void operator()()
    {
      if (ptr.get() == 0) {
        ptr.reset(new int(0));
      }

      for (int i = 0; i < 10; ++i)
      {
        *ptr += step;
        boost::mutex::scoped_lock lock(mio);
        cout << boost::this_thread::get_id() << ": "
             << *ptr << endl;
        boost::this_thread::sleep(boost::posix_time::milliseconds(15));
      }
    }
  };
}

void dd05()
{
  boost::thread t1(Count(1));
  boost::thread t2(Count(-1));
  t1.join();
  t2.join();
}

Vengono creati due thread, associati ad un functor che viene costruito col parametro passato che viene utilizzato in un loop per modificare un valore locale al thread.

Per prima cosa verifichiamo che l'istanza di boost::thread_specific_ptr sia NULL, e la inizializziamo come richiesto. Poi facciamo un loop che incrementa di passo in passo la nostra variabile locale al thread e la stampa su cout, opportunamente protetto da un lock su mutex. Ho aggiunto uno sleep sul thread in modo da rendere più movimentata la competizione dei thread sul mutex.