17-2

// Joshua Calloway
// cspp51045
// 17-2
//
#include <iostream>
#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
 
using namespace std;
 
class SingleThreadedPolicy {
public:
  inline void lock(boost::mutex& mutex1) {
  }
  inline void unlock(boost::mutex& mutex1) {
  }
 
protected:
  SingleThreadedPolicy() {}
 
};
 
 
class MultiThreadedPolicy {
public:
  inline void lock(boost::mutex& mutex1) {
    //boost::mutex::scoped_lock lk(mutex1);
    lk = new boost::mutex::scoped_lock(mutex1);
  }
  inline void unlock(boost::mutex& mutex1) {
    lk->unlock();
  }
protected:
  boost::mutex::scoped_lock *lk;
  MultiThreadedPolicy() {}
};
 
template<class ThreadingModel = SingleThreadedPolicy>
class A : public ThreadingModel {
 
public:
  static A* get_instance() {
    ThreadingModel::lock(st_mutex);
    return new A;
    ThreadingModel::unlock(st_mutex);
  }
 
  virtual void bump(int i = 1) {
    ThreadingModel::lock(mutex1);
    //cout << "bump : " << i << " a is : " << a << endl;
    a += i;
    ThreadingModel::unlock(mutex1);
  }
 
  int get_a() const { return a; }
  A() : a(0) {}
 
private:
  boost::mutex mutex1;
  static boost::mutex st_mutex;
 
  int a;
};
 
 
template<class X>
struct increment_a
{
  X& a;
  int i;
  increment_a(X& a) : a(a), i(1) {}
  increment_a(X& a, int i) : a(a), i(i) {}
 
  void operator()() {
    for (int j = 0; j < 100; j++) {
      a.bump(i);
      boost::thread::yield();
    }
  }
};
 
int main() {
  typedef A<MultiThreadedPolicy> AA;
  typedef A<SingleThreadedPolicy> SS;
 
  AA* a1 = new AA;
  boost::thread_group thrds;
  thrds.add_thread(new boost::thread(increment_a<AA>(*a1)));
  thrds.add_thread(new boost::thread(increment_a<AA>(*a1, 10)));
  thrds.add_thread(new boost::thread(increment_a<AA>(*a1, 100)));
 
  SS* s1 = new SS;
  thrds.add_thread(new boost::thread(increment_a<SS>(*s1)));
  thrds.add_thread(new boost::thread(increment_a<SS>(*s1, 10)));
 
  thrds.join_all();
  cout << "a1 : " << a1->get_a() << endl;
}