Index: boost/thread/pthread/shared_mutex.hpp
===================================================================
--- boost/thread/pthread/shared_mutex.hpp	(revision 47043)
+++ boost/thread/pthread/shared_mutex.hpp	(working copy)
@@ -10,7 +10,7 @@
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/thread/mutex.hpp>
-#include <boost/thread/thread.hpp>
+#include <boost/thread/detail/interruption_control.hpp>
 #include <boost/thread/condition_variable.hpp>
 
 #include <boost/config/abi_prefix.hpp>
Index: boost/thread/detail/interruption_control.hpp
===================================================================
--- boost/thread/detail/interruption_control.hpp	(revision 0)
+++ boost/thread/detail/interruption_control.hpp	(revision 0)
@@ -0,0 +1,35 @@
+#ifndef BOOST_THREAD_DETAIL_INTERRUPTION_CONTROL_HPP
+#define BOOST_THREAD_DETAIL_INTERRUPTION_CONTROL_HPP
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/detail/config.hpp>
+
+namespace boost
+{
+    namespace this_thread
+    {
+        class BOOST_THREAD_DECL disable_interruption
+        {
+            disable_interruption(const disable_interruption&);
+            disable_interruption& operator=(const disable_interruption&);
+            
+            bool interruption_was_enabled;
+            friend class restore_interruption;
+        public:
+            disable_interruption();
+            ~disable_interruption();
+        };
+
+        class BOOST_THREAD_DECL restore_interruption
+        {
+            restore_interruption(const restore_interruption&);
+            restore_interruption& operator=(const restore_interruption&);
+        public:
+            explicit restore_interruption(disable_interruption& d);
+            ~restore_interruption();
+        };
+    }
+}
+#endif
Index: boost/thread/detail/thread.hpp
===================================================================
--- boost/thread/detail/thread.hpp	(revision 47043)
+++ boost/thread/detail/thread.hpp	(working copy)
@@ -9,8 +9,10 @@
 #include <ostream>
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/mutex.hpp>
+#include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/xtime.hpp>
 #include <boost/thread/detail/thread_heap_alloc.hpp>
+#include <boost/thread/detail/interruption_control.hpp>
 #include <boost/utility.hpp>
 #include <boost/assert.hpp>
 #include <list>
@@ -338,6 +340,7 @@
 
     namespace this_thread
     {
+#if 0  // moved to interruption_control.hpp
         class BOOST_THREAD_DECL disable_interruption
         {
             disable_interruption(const disable_interruption&);
@@ -358,6 +361,7 @@
             explicit restore_interruption(disable_interruption& d);
             ~restore_interruption();
         };
+#endif
 
         thread::id BOOST_THREAD_DECL get_id();
 
@@ -496,7 +500,7 @@
         template<typename F>
         thread* create_thread(F threadfunc)
         {
-            boost::lock_guard<mutex> guard(m);
+            boost::lock_guard<shared_mutex> guard(m);
             std::auto_ptr<thread> new_thread(new thread(threadfunc));
             threads.push_back(new_thread.get());
             return new_thread.release();
@@ -506,14 +510,14 @@
         {
             if(thrd)
             {
-                boost::lock_guard<mutex> guard(m);
+                boost::lock_guard<shared_mutex> guard(m);
                 threads.push_back(thrd);
             }
         }
             
         void remove_thread(thread* thrd)
         {
-            boost::lock_guard<mutex> guard(m);
+            boost::lock_guard<shared_mutex> guard(m);
             std::list<thread*>::iterator const it=std::find(threads.begin(),threads.end(),thrd);
             if(it!=threads.end())
             {
@@ -523,7 +527,7 @@
         
         void join_all()
         {
-            boost::lock_guard<mutex> guard(m);
+            boost::shared_lock<shared_mutex> guard(m);
             
             for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
                 it!=end;
@@ -535,7 +539,7 @@
         
         void interrupt_all()
         {
-            boost::lock_guard<mutex> guard(m);
+            boost::shared_lock<shared_mutex> guard(m);
             
             for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
                 it!=end;
@@ -547,13 +551,13 @@
         
         size_t size() const
         {
-            boost::lock_guard<mutex> guard(m);
+            boost::shared_lock<shared_mutex> guard(m);
             return threads.size();
         }
         
     private:
         std::list<thread*> threads;
-        mutable mutex m;
+        mutable shared_mutex m;
     };
 }