libs/thread/test/shared_mutex_locking_thread.hpp

   1 #ifndef SHARED_MUTEX_LOCKING_THREAD_HPP
   2 #define SHARED_MUTEX_LOCKING_THREAD_HPP
   3
   4 //  (C) Copyright 2008 Anthony Williams
   5 //
   6 //  Distributed under the Boost Software License, Version 1.0. (See
   7 //  accompanying file LICENSE_1_0.txt or copy at
   8 //  http://www.boost.org/LICENSE_1_0.txt)
   9
  10 #include <boost/thread/mutex.hpp>
  11 #include <boost/thread/condition_variable.hpp>
  12 #include <boost/thread/shared_mutex.hpp>
  13
  14 template<typename lock_type>
  15 class locking_thread
  16 {
  17     boost::shared_mutex& rw_mutex;
  18     unsigned& unblocked_count;
  19     boost::condition_variable& unblocked_condition;
  20     unsigned& simultaneous_running_count;
  21     unsigned& max_simultaneous_running;
  22     boost::mutex& unblocked_count_mutex;
  23     boost::mutex& finish_mutex;
  24 public:
  25     locking_thread(boost::shared_mutex& rw_mutex_,
  26                    unsigned& unblocked_count_,
  27                    boost::mutex& unblocked_count_mutex_,
  28                    boost::condition_variable& unblocked_condition_,
  29                    boost::mutex& finish_mutex_,
  30                    unsigned& simultaneous_running_count_,
  31                    unsigned& max_simultaneous_running_):
  32         rw_mutex(rw_mutex_),
  33         unblocked_count(unblocked_count_),
  34         unblocked_condition(unblocked_condition_),
  35         simultaneous_running_count(simultaneous_running_count_),
  36         max_simultaneous_running(max_simultaneous_running_),
  37         unblocked_count_mutex(unblocked_count_mutex_),
  38         finish_mutex(finish_mutex_)
  39     {}
  40
  41     void operator()()
  42     {
  43         // acquire lock
  44         lock_type lock(rw_mutex);
  45
  46         // increment count to show we're unblocked
  47         {
  48             boost::mutex::scoped_lock ublock(unblocked_count_mutex);
  49             ++unblocked_count;
  50             unblocked_condition.notify_one();
  51             ++simultaneous_running_count;
  52             if(simultaneous_running_count>max_simultaneous_running)
  53             {
  54                 max_simultaneous_running=simultaneous_running_count;
  55             }
  56         }
  57
  58         // wait to finish
  59         boost::mutex::scoped_lock finish_lock(finish_mutex);
  60         {
  61             boost::mutex::scoped_lock ublock(unblocked_count_mutex);
  62             --simultaneous_running_count;
  63         }
  64     }
  65 private:
  66     void operator=(locking_thread&);
  67 };
  68
  69 class simple_writing_thread
  70 {
  71     boost::shared_mutex& rwm;
  72     boost::mutex& finish_mutex;
  73     boost::mutex& unblocked_mutex;
  74     unsigned& unblocked_count;
  75
  76     void operator=(simple_writing_thread&);
  77
  78 public:
  79     simple_writing_thread(boost::shared_mutex& rwm_,
  80                           boost::mutex& finish_mutex_,
  81                           boost::mutex& unblocked_mutex_,
  82                           unsigned& unblocked_count_):
  83         rwm(rwm_),finish_mutex(finish_mutex_),
  84         unblocked_mutex(unblocked_mutex_),unblocked_count(unblocked_count_)
  85     {}
  86
  87     void operator()()
  88     {
  89         boost::unique_lock<boost::shared_mutex>  lk(rwm);
  90
  91         {
  92             boost::mutex::scoped_lock ulk(unblocked_mutex);
  93             ++unblocked_count;
  94         }
  95
  96         boost::mutex::scoped_lock flk(finish_mutex);
  97     }
  98 };
  99
 100 class simple_reading_thread
 101 {
 102     boost::shared_mutex& rwm;
 103     boost::mutex& finish_mutex;
 104     boost::mutex& unblocked_mutex;
 105     unsigned& unblocked_count;
 106
 107     void operator=(simple_reading_thread&);
 108
 109 public:
 110     simple_reading_thread(boost::shared_mutex& rwm_,
 111                           boost::mutex& finish_mutex_,
 112                           boost::mutex& unblocked_mutex_,
 113                           unsigned& unblocked_count_):
 114         rwm(rwm_),finish_mutex(finish_mutex_),
 115         unblocked_mutex(unblocked_mutex_),unblocked_count(unblocked_count_)
 116     {}
 117
 118     void operator()()
 119     {
 120         boost::shared_lock<boost::shared_mutex>  lk(rwm);
 121
 122         {
 123             boost::mutex::scoped_lock ulk(unblocked_mutex);
 124             ++unblocked_count;
 125         }
 126
 127         boost::mutex::scoped_lock flk(finish_mutex);
 128     }
 129 };
 130
 131
 132 #endif