rw_lock.hpp

Go to the documentation of this file.

#pragma once

#include <xtd/concurrent/concurrent.hpp>

namespace xtd{
  namespace concurrent{
    template <typename _WaitPolicyT>
    class rw_lock_base{
      std::atomic<uint32_t> _lock;
      static constexpr uint32_t write_lock_bit = 0x80000000;
      static constexpr uint32_t read_bits_mask = ~write_lock_bit;
      _WaitPolicyT _WaitPolicy;
    public:
      using wait_policy_type = _WaitPolicyT;
      rw_lock_base(wait_policy_type oWait = wait_policy_type()) : _lock(0), _WaitPolicy(oWait){}
      uint32_t readers() const{
        return _lock.load() & read_bits_mask;
      }

      void unlock(){
        forever{
          auto iOriginal = _lock.load();
          if (write_lock_bit == iOriginal){
            _lock.store(0);
            break;
          } else{
            if (_lock.compare_exchange_strong(iOriginal, iOriginal - 1)){
              break;
            }
          }
          _WaitPolicy();
        }
      }
      void lock_read(){
        forever{
          auto iOriginal = _lock.load() & read_bits_mask;
          if (_lock.compare_exchange_strong(iOriginal, 1 + iOriginal)){
            break;
          }
          _WaitPolicy();
        }
      }
      bool try_lock_read(){
        auto iOriginal = _lock.load() & read_bits_mask;
        return _lock.compare_exchange_strong(iOriginal, 1 + iOriginal);
      }
      void lock_write(){
        uint32_t iOriginal = 0;
        while (!_lock.compare_exchange_strong(iOriginal, write_lock_bit)){
          _WaitPolicy();
        }
      }
      bool try_lock_write(){
        uint32_t iOriginal = 0;
        return _lock.compare_exchange_strong(iOriginal, write_lock_bit);
      }
      class scope_read{
        rw_lock_base& _Lock;
      public:
        explicit scope_read(rw_lock_base& oLock) : _Lock(oLock){
          _Lock.lock_read();
        }
        ~scope_read(){
          _Lock.unlock();
        }
      };
      class scope_write{
        rw_lock_base& _Lock;
      public:
        explicit scope_write(rw_lock_base& oLock) : _Lock(oLock){
          _Lock.lock_write();
        }
        ~scope_write(){
          _Lock.unlock();
        }
      };
    };

    using rw_lock = rw_lock_base<null_wait_policy>;
  }
}