00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028 #ifndef _util_group_thread_h
00029 #define _util_group_thread_h
00030
00031 #ifdef __GNUC__
00032 #pragma interface
00033 #endif
00034
00035 #include <util/class/class.h>
00036
00037 namespace sc {
00038
00044 class ThreadLock : public RefCount {
00045 public:
00046 ThreadLock();
00047 virtual ~ThreadLock();
00048
00050 virtual void lock() =0;
00052 virtual void unlock() =0;
00053 };
00054
00055
00060 class ThreadLockHolder {
00061 Ref<ThreadLock> lock_;
00062 bool locked_;
00063 public:
00065 ThreadLockHolder(const Ref<ThreadLock> &l): lock_(l) {
00066 lock_->lock();
00067 locked_ = true;
00068 }
00070 void unlock() { if (locked_) { lock_->unlock(); locked_ = false; } }
00072 void lock() { if (!locked_) { lock_->lock(); locked_ = true; } }
00074 ~ThreadLockHolder() { unlock(); }
00075 };
00076
00079 class Thread {
00080 public:
00081 Thread();
00082 virtual ~Thread();
00083
00084 static void *run_Thread_run(void*thread);
00085
00087 virtual void run() =0;
00088 };
00089
00092 class ThreadGrp: public DescribedClass {
00093 protected:
00094 Thread** threads_;
00095 int nthread_;
00096
00097 public:
00098 ThreadGrp();
00099 ThreadGrp(const Ref<KeyVal>&);
00100 ThreadGrp(const ThreadGrp&, int nthread = -1);
00101 virtual ~ThreadGrp();
00102
00105 virtual void add_thread(int threadnum, Thread* thread);
00109 virtual void add_thread(int threadnum, Thread* thread, int priority);
00111 int nthread() const { return nthread_; }
00112
00113 void delete_threads();
00114
00117 virtual int start_threads() =0;
00120 virtual int wait_threads() =0;
00122 virtual Ref<ThreadLock> new_lock() =0;
00123
00128 virtual ThreadGrp* clone(int nthread = -1);
00129
00130 static void set_default_threadgrp(const Ref<ThreadGrp>&);
00131 static ThreadGrp * get_default_threadgrp();
00132 static ThreadGrp * initial_threadgrp(int &argc, char ** argv);
00133 };
00134
00135
00139 class ProcThreadGrp: public ThreadGrp {
00140 public:
00141 ProcThreadGrp();
00142 ProcThreadGrp(const Ref<KeyVal>&);
00143 ~ProcThreadGrp();
00144
00145 int start_threads();
00146 int wait_threads();
00147
00148 Ref<ThreadLock> new_lock();
00149
00150 ThreadGrp* clone(int nthread = -1);
00151 };
00152
00153 }
00154
00155 extern "C" {
00156
00157 void *Thread__run_Thread_run(void*thread);
00158 }
00159
00160 #endif
00161
00162
00163
00164
00165