/Src/Dependencies/Boost/boost/thread/win32/basic_recursive_mutex.hpp

http://hadesmem.googlecode.com/ · C++ Header · 120 lines · 96 code · 17 blank · 7 comment · 7 complexity · c665a5379e6cedf37b0b3e20545415cd MD5 · raw file

  1. #ifndef BOOST_BASIC_RECURSIVE_MUTEX_WIN32_HPP
  2. #define BOOST_BASIC_RECURSIVE_MUTEX_WIN32_HPP
  3. // basic_recursive_mutex.hpp
  4. //
  5. // (C) Copyright 2006-8 Anthony Williams
  6. //
  7. // Distributed under the Boost Software License, Version 1.0. (See
  8. // accompanying file LICENSE_1_0.txt or copy at
  9. // http://www.boost.org/LICENSE_1_0.txt)
  10. #include "thread_primitives.hpp"
  11. #include "basic_timed_mutex.hpp"
  12. #include <boost/config/abi_prefix.hpp>
  13. namespace boost
  14. {
  15. namespace detail
  16. {
  17. template<typename underlying_mutex_type>
  18. struct basic_recursive_mutex_impl
  19. {
  20. long recursion_count;
  21. long locking_thread_id;
  22. underlying_mutex_type mutex;
  23. void initialize()
  24. {
  25. recursion_count=0;
  26. locking_thread_id=0;
  27. mutex.initialize();
  28. }
  29. void destroy()
  30. {
  31. mutex.destroy();
  32. }
  33. bool try_lock()
  34. {
  35. long const current_thread_id=win32::GetCurrentThreadId();
  36. return try_recursive_lock(current_thread_id) || try_basic_lock(current_thread_id);
  37. }
  38. void lock()
  39. {
  40. long const current_thread_id=win32::GetCurrentThreadId();
  41. if(!try_recursive_lock(current_thread_id))
  42. {
  43. mutex.lock();
  44. BOOST_INTERLOCKED_EXCHANGE(&locking_thread_id,current_thread_id);
  45. recursion_count=1;
  46. }
  47. }
  48. bool timed_lock(::boost::system_time const& target)
  49. {
  50. long const current_thread_id=win32::GetCurrentThreadId();
  51. return try_recursive_lock(current_thread_id) || try_timed_lock(current_thread_id,target);
  52. }
  53. template<typename Duration>
  54. bool timed_lock(Duration const& timeout)
  55. {
  56. return timed_lock(get_system_time()+timeout);
  57. }
  58. void unlock()
  59. {
  60. if(!--recursion_count)
  61. {
  62. BOOST_INTERLOCKED_EXCHANGE(&locking_thread_id,0);
  63. mutex.unlock();
  64. }
  65. }
  66. private:
  67. bool try_recursive_lock(long current_thread_id)
  68. {
  69. if(::boost::detail::interlocked_read_acquire(&locking_thread_id)==current_thread_id)
  70. {
  71. ++recursion_count;
  72. return true;
  73. }
  74. return false;
  75. }
  76. bool try_basic_lock(long current_thread_id)
  77. {
  78. if(mutex.try_lock())
  79. {
  80. BOOST_INTERLOCKED_EXCHANGE(&locking_thread_id,current_thread_id);
  81. recursion_count=1;
  82. return true;
  83. }
  84. return false;
  85. }
  86. bool try_timed_lock(long current_thread_id,::boost::system_time const& target)
  87. {
  88. if(mutex.timed_lock(target))
  89. {
  90. BOOST_INTERLOCKED_EXCHANGE(&locking_thread_id,current_thread_id);
  91. recursion_count=1;
  92. return true;
  93. }
  94. return false;
  95. }
  96. };
  97. typedef basic_recursive_mutex_impl<basic_timed_mutex> basic_recursive_mutex;
  98. typedef basic_recursive_mutex_impl<basic_timed_mutex> basic_recursive_timed_mutex;
  99. }
  100. }
  101. #define BOOST_BASIC_RECURSIVE_MUTEX_INITIALIZER {0}
  102. #include <boost/config/abi_suffix.hpp>
  103. #endif