boost/thread/detail/thread.hpp

   1 #ifndef BOOST_THREAD_THREAD_COMMON_HPP
   2 #define BOOST_THREAD_THREAD_COMMON_HPP
   3 // Distributed under the Boost Software License, Version 1.0. (See
   4 // accompanying file LICENSE_1_0.txt or copy at
   5 // http://www.boost.org/LICENSE_1_0.txt)
   6 // (C) Copyright 2007-8 Anthony Williams
   7
   8 #include <boost/thread/exceptions.hpp>
   9 #include <ostream>
  10 #include <boost/thread/detail/move.hpp>
  11 #include <boost/thread/mutex.hpp>
  12 #include <boost/thread/xtime.hpp>
  13 #include <boost/thread/detail/thread_heap_alloc.hpp>
  14 #include <boost/utility.hpp>
  15 #include <boost/assert.hpp>
  16 #include <list>
  17 #include <algorithm>
  18 #include <boost/ref.hpp>
  19 #include <boost/cstdint.hpp>
  20 #include <boost/bind.hpp>
  21 #include <stdlib.h>
  22 #include <memory>
  23 #include <boost/utility/enable_if.hpp>
  24 #include <boost/type_traits/remove_reference.hpp>
  25
  26 #include <boost/config/abi_prefix.hpp>
  27
  28 #ifdef BOOST_MSVC
  29 #pragma warning(push)
  30 #pragma warning(disable:4251)
  31 #endif
  32
  33 namespace boost
  34 {
  35     namespace detail
  36     {
  37         template<typename F>
  38         class thread_data:
  39             public detail::thread_data_base
  40         {
  41         public:
  42 #ifdef BOOST_HAS_RVALUE_REFS
  43             thread_data(F&& f_):
  44                 f(static_cast<F&&>(f_))
  45             {}
  46 #else
  47             thread_data(F f_):
  48                 f(f_)
  49             {}
  50             thread_data(detail::thread_move_t<F> f_):
  51                 f(f_)
  52             {}
  53 #endif
  54             void run()
  55             {
  56                 f();
  57             }
  58         private:
  59             F f;
  60
  61             void operator=(thread_data&);
  62             thread_data(thread_data&);
  63         };
  64
  65         template<typename F>
  66         class thread_data<boost::reference_wrapper<F> >:
  67             public detail::thread_data_base
  68         {
  69         private:
  70             F& f;
  71
  72             void operator=(thread_data&);
  73             thread_data(thread_data&);
  74         public:
  75             thread_data(boost::reference_wrapper<F> f_):
  76                 f(f_)
  77             {}
  78
  79             void run()
  80             {
  81                 f();
  82             }
  83         };
  84
  85         template<typename F>
  86         class thread_data<const boost::reference_wrapper<F> >:
  87             public detail::thread_data_base
  88         {
  89         private:
  90             F& f;
  91             void operator=(thread_data&);
  92             thread_data(thread_data&);
  93         public:
  94             thread_data(const boost::reference_wrapper<F> f_):
  95                 f(f_)
  96             {}
  97
  98             void run()
  99             {
 100                 f();
 101             }
 102         };
 103     }
 104
 105     class BOOST_THREAD_DECL thread
 106     {
 107     private:
 108         thread(thread&);
 109         thread& operator=(thread&);
 110
 111         void release_handle();
 112
 113         mutable boost::mutex thread_info_mutex;
 114         detail::thread_data_ptr thread_info;
 115
 116         void start_thread();
 117
 118         explicit thread(detail::thread_data_ptr data);
 119
 120         detail::thread_data_ptr get_thread_info() const;
 121
 122 #ifdef BOOST_HAS_RVALUE_REFS
 123         template<typename F>
 124         static inline detail::thread_data_ptr make_thread_info(F&& f)
 125         {
 126             return detail::thread_data_ptr(detail::heap_new<detail::thread_data<typename boost::remove_reference<F>::type> >(static_cast<F&&>(f)));
 127         }
 128         static inline detail::thread_data_ptr make_thread_info(void (*f)())
 129         {
 130             return detail::thread_data_ptr(detail::heap_new<detail::thread_data<void(*)()> >(f));
 131         }
 132 #else
 133         template<typename F>
 134         static inline detail::thread_data_ptr make_thread_info(F f)
 135         {
 136             return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(f));
 137         }
 138         template<typename F>
 139         static inline detail::thread_data_ptr make_thread_info(boost::detail::thread_move_t<F> f)
 140         {
 141             return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(f));
 142         }
 143
 144         struct dummy;
 145 #endif
 146     public:
 147         thread();
 148         ~thread();
 149
 150 #ifdef BOOST_HAS_RVALUE_REFS
 151         template <class F>
 152         thread(F&& f):
 153             thread_info(make_thread_info(static_cast<F&&>(f)))
 154         {
 155             start_thread();
 156         }
 157
 158         thread(thread&& other)
 159         {
 160             thread_info.swap(other.thread_info);
 161         }
 162
 163         thread& operator=(thread&& other)
 164         {
 165             thread_info=other.thread_info;
 166             other.thread_info.reset();
 167             return *this;
 168         }
 169
 170         thread&& move()
 171         {
 172             return static_cast<thread&&>(*this);
 173         }
 174
 175 #else
 176 #ifdef BOOST_NO_SFINAE
 177         template <class F>
 178         explicit thread(F f):
 179             thread_info(make_thread_info(f))
 180         {
 181             start_thread();
 182         }
 183 #else
 184         template <class F>
 185         explicit thread(F f,typename disable_if<boost::is_convertible<F&,detail::thread_move_t<F> >, dummy* >::type=0):
 186             thread_info(make_thread_info(f))
 187         {
 188             start_thread();
 189         }
 190 #endif
 191
 192         template <class F>
 193         explicit thread(detail::thread_move_t<F> f):
 194             thread_info(make_thread_info(f))
 195         {
 196             start_thread();
 197         }
 198
 199         thread(detail::thread_move_t<thread> x)
 200         {
 201             thread_info=x->thread_info;
 202             x->thread_info.reset();
 203         }
 204
 205         thread& operator=(detail::thread_move_t<thread> x)
 206         {
 207             thread new_thread(x);
 208             swap(new_thread);
 209             return *this;
 210         }
 211
 212         operator detail::thread_move_t<thread>()
 213         {
 214             return move();
 215         }
 216
 217         detail::thread_move_t<thread> move()
 218         {
 219             detail::thread_move_t<thread> x(*this);
 220             return x;
 221         }
 222
 223 #endif
 224
 225         template <class F,class A1>
 226         thread(F f,A1 a1):
 227             thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1)))
 228         {
 229             start_thread();
 230         }
 231         template <class F,class A1,class A2>
 232         thread(F f,A1 a1,A2 a2):
 233             thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2)))
 234         {
 235             start_thread();
 236         }
 237
 238         template <class F,class A1,class A2,class A3>
 239         thread(F f,A1 a1,A2 a2,A3 a3):
 240             thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3)))
 241         {
 242             start_thread();
 243         }
 244
 245         template <class F,class A1,class A2,class A3,class A4>
 246         thread(F f,A1 a1,A2 a2,A3 a3,A4 a4):
 247             thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4)))
 248         {
 249             start_thread();
 250         }
 251
 252         template <class F,class A1,class A2,class A3,class A4,class A5>
 253         thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5):
 254             thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5)))
 255         {
 256             start_thread();
 257         }
 258
 259         template <class F,class A1,class A2,class A3,class A4,class A5,class A6>
 260         thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6):
 261             thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6)))
 262         {
 263             start_thread();
 264         }
 265
 266         template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7>
 267         thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7):
 268             thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7)))
 269         {
 270             start_thread();
 271         }
 272
 273         template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>
 274         thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8):
 275             thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7,a8)))
 276         {
 277             start_thread();
 278         }
 279
 280         template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9>
 281         thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9):
 282             thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7,a8,a9)))
 283         {
 284             start_thread();
 285         }
 286
 287         void swap(thread& x)
 288         {
 289             thread_info.swap(x.thread_info);
 290         }
 291
 292         class id;
 293         id get_id() const;
 294
 295
 296         bool joinable() const;
 297         void join();
 298         bool timed_join(const system_time& wait_until);
 299
 300         template<typename TimeDuration>
 301         inline bool timed_join(TimeDuration const& rel_time)
 302         {
 303             return timed_join(get_system_time()+rel_time);
 304         }
 305         void detach();
 306
 307         static unsigned hardware_concurrency();
 308
 309         typedef detail::thread_data_base::native_handle_type native_handle_type;
 310         native_handle_type native_handle();
 311
 312         // backwards compatibility
 313         bool operator==(const thread& other) const;
 314         bool operator!=(const thread& other) const;
 315
 316         static inline void yield()
 317         {
 318             this_thread::yield();
 319         }
 320
 321         static inline void sleep(const system_time& xt)
 322         {
 323             this_thread::sleep(xt);
 324         }
 325
 326         // extensions
 327         void interrupt();
 328         bool interruption_requested() const;
 329     };
 330
 331     inline void swap(thread& lhs,thread& rhs)
 332     {
 333         return lhs.swap(rhs);
 334     }
 335
 336 #ifdef BOOST_HAS_RVALUE_REFS
 337     inline thread&& move(thread&& t)
 338     {
 339         return t;
 340     }
 341 #else
 342     inline thread move(detail::thread_move_t<thread> t)
 343     {
 344         return thread(t);
 345     }
 346 #endif
 347
 348     namespace this_thread
 349     {
 350         class BOOST_THREAD_DECL disable_interruption
 351         {
 352             disable_interruption(const disable_interruption&);
 353             disable_interruption& operator=(const disable_interruption&);
 354
 355             bool interruption_was_enabled;
 356             friend class restore_interruption;
 357         public:
 358             disable_interruption();
 359             ~disable_interruption();
 360         };
 361
 362         class BOOST_THREAD_DECL restore_interruption
 363         {
 364             restore_interruption(const restore_interruption&);
 365             restore_interruption& operator=(const restore_interruption&);
 366         public:
 367             explicit restore_interruption(disable_interruption& d);
 368             ~restore_interruption();
 369         };
 370
 371         thread::id BOOST_THREAD_DECL get_id();
 372
 373         void BOOST_THREAD_DECL interruption_point();
 374         bool BOOST_THREAD_DECL interruption_enabled();
 375         bool BOOST_THREAD_DECL interruption_requested();
 376
 377         inline void sleep(xtime const& abs_time)
 378         {
 379             sleep(system_time(abs_time));
 380         }
 381     }
 382
 383     class thread::id
 384     {
 385     private:
 386         detail::thread_data_ptr thread_data;
 387
 388         id(detail::thread_data_ptr thread_data_):
 389             thread_data(thread_data_)
 390         {}
 391         friend class thread;
 392         friend id this_thread::get_id();
 393     public:
 394         id():
 395             thread_data()
 396         {}
 397
 398         bool operator==(const id& y) const
 399         {
 400             return thread_data==y.thread_data;
 401         }
 402
 403         bool operator!=(const id& y) const
 404         {
 405             return thread_data!=y.thread_data;
 406         }
 407
 408         bool operator<(const id& y) const
 409         {
 410             return thread_data<y.thread_data;
 411         }
 412
 413         bool operator>(const id& y) const
 414         {
 415             return y.thread_data<thread_data;
 416         }
 417
 418         bool operator<=(const id& y) const
 419         {
 420             return !(y.thread_data<thread_data);
 421         }
 422
 423         bool operator>=(const id& y) const
 424         {
 425             return !(thread_data<y.thread_data);
 426         }
 427
 428         template<class charT, class traits>
 429         friend std::basic_ostream<charT, traits>&
 430         operator<<(std::basic_ostream<charT, traits>& os, const id& x)
 431         {
 432             if(x.thread_data)
 433             {
 434                 return os<<x.thread_data;
 435             }
 436             else
 437             {
 438                 return os<<"{Not-any-thread}";
 439             }
 440         }
 441     };
 442
 443     inline bool thread::operator==(const thread& other) const
 444     {
 445         return get_id()==other.get_id();
 446     }
 447
 448     inline bool thread::operator!=(const thread& other) const
 449     {
 450         return get_id()!=other.get_id();
 451     }
 452
 453     namespace detail
 454     {
 455         struct thread_exit_function_base
 456         {
 457             virtual ~thread_exit_function_base()
 458             {}
 459             virtual void operator()() const=0;
 460         };
 461
 462         template<typename F>
 463         struct thread_exit_function:
 464             thread_exit_function_base
 465         {
 466             F f;
 467
 468             thread_exit_function(F f_):
 469                 f(f_)
 470             {}
 471
 472             void operator()() const
 473             {
 474                 f();
 475             }
 476         };
 477
 478         void add_thread_exit_function(thread_exit_function_base*);
 479     }
 480
 481     namespace this_thread
 482     {
 483         template<typename F>
 484         void at_thread_exit(F f)
 485         {
 486             detail::thread_exit_function_base* const thread_exit_func=detail::heap_new<detail::thread_exit_function<F> >(f);
 487             detail::add_thread_exit_function(thread_exit_func);
 488         }
 489     }
 490
 491     class thread_group:
 492         private noncopyable
 493     {
 494     public:
 495         ~thread_group()
 496         {
 497             for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
 498                 it!=end;
 499                 ++it)
 500             {
 501                 delete *it;
 502             }
 503         }
 504
 505         template<typename F>
 506         thread* create_thread(F threadfunc)
 507         {
 508             boost::lock_guard<mutex> guard(m);
 509             std::auto_ptr<thread> new_thread(new thread(threadfunc));
 510             threads.push_back(new_thread.get());
 511             return new_thread.release();
 512         }
 513
 514         void add_thread(thread* thrd)
 515         {
 516             if(thrd)
 517             {
 518                 boost::lock_guard<mutex> guard(m);
 519                 threads.push_back(thrd);
 520             }
 521         }
 522
 523         void remove_thread(thread* thrd)
 524         {
 525             boost::lock_guard<mutex> guard(m);
 526             std::list<thread*>::iterator const it=std::find(threads.begin(),threads.end(),thrd);
 527             if(it!=threads.end())
 528             {
 529                 threads.erase(it);
 530             }
 531         }
 532
 533         void join_all()
 534         {
 535             boost::lock_guard<mutex> guard(m);
 536
 537             for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
 538                 it!=end;
 539                 ++it)
 540             {
 541                 (*it)->join();
 542             }
 543         }
 544
 545         void interrupt_all()
 546         {
 547             boost::lock_guard<mutex> guard(m);
 548
 549             for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
 550                 it!=end;
 551                 ++it)
 552             {
 553                 (*it)->interrupt();
 554             }
 555         }
 556
 557         size_t size() const
 558         {
 559             boost::lock_guard<mutex> guard(m);
 560             return threads.size();
 561         }
 562
 563     private:
 564         std::list<thread*> threads;
 565         mutable mutex m;
 566     };
 567 }
 568
 569 #ifdef BOOST_MSVC
 570 #pragma warning(pop)
 571 #endif
 572
 573 #include <boost/config/abi_suffix.hpp>
 574
 575 #endif