MPQC 2.3.1
thread.h
1//
2// thread.h
3//
4// Copyright (C) 1997 Limit Point Systems, Inc.
5//
6// Author: Edward Seidl <seidl@janed.com>
7// Maintainer: LPS
8//
9// This file is part of the SC Toolkit.
10//
11// The SC Toolkit is free software; you can redistribute it and/or modify
12// it under the terms of the GNU Library General Public License as published by
13// the Free Software Foundation; either version 2, or (at your option)
14// any later version.
15//
16// The SC Toolkit is distributed in the hope that it will be useful,
17// but WITHOUT ANY WARRANTY; without even the implied warranty of
18// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19// GNU Library General Public License for more details.
20//
21// You should have received a copy of the GNU Library General Public License
22// along with the SC Toolkit; see the file COPYING.LIB. If not, write to
23// the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
24//
25// The U.S. Government is granted a limited license as per AL 91-7.
26//
27
28#ifndef _util_group_thread_h
29#define _util_group_thread_h
30
31#ifdef __GNUC__
32#pragma interface
33#endif
34
35#include <util/class/class.h>
36
37namespace sc {
38
44class ThreadLock : public RefCount {
45 public:
46 ThreadLock();
47 virtual ~ThreadLock();
48
50 virtual void lock() =0;
52 virtual void unlock() =0;
53};
54
55
61 Ref<ThreadLock> lock_;
62 bool locked_;
63 public:
65 ThreadLockHolder(const Ref<ThreadLock> &l): lock_(l) {
66 lock_->lock();
67 locked_ = true;
68 }
70 void unlock() { if (locked_) { lock_->unlock(); locked_ = false; } }
72 void lock() { if (!locked_) { lock_->lock(); locked_ = true; } }
75};
76
79class Thread {
80 public:
81 Thread();
82 virtual ~Thread();
83
84 static void *run_Thread_run(void*thread);
85
87 virtual void run() =0;
88};
89
93 protected:
94 Thread** threads_;
95 int nthread_;
96
97 public:
98 ThreadGrp();
99 ThreadGrp(const Ref<KeyVal>&);
100 ThreadGrp(const ThreadGrp&, int nthread = -1);
101 virtual ~ThreadGrp();
102
105 virtual void add_thread(int threadnum, Thread* thread);
109 virtual void add_thread(int threadnum, Thread* thread, int priority);
111 int nthread() const { return nthread_; }
112
113 void delete_threads();
114
117 virtual int start_threads() =0;
120 virtual int wait_threads() =0;
123
128 virtual ThreadGrp* clone(int nthread = -1);
129
130 static void set_default_threadgrp(const Ref<ThreadGrp>&);
131 static ThreadGrp * get_default_threadgrp();
132 static ThreadGrp * initial_threadgrp(int &argc, char ** argv);
133};
134
135
140 public:
144
147
149
151};
152
153}
154
155extern "C" {
156 // a C linkage interface to run_Thread_run
157 void *Thread__run_Thread_run(void*thread);
158}
159
160#endif
161
162// Local Variables:
163// mode: c++
164// c-file-style: "ETS"
165// End:
Classes which need runtime information about themselves and their relationship to other classes can v...
Definition: class.h:244
The ProcThreadGrp class privides a concrete thread group appropriate for an environment where there i...
Definition: thread.h:139
Ref< ThreadLock > new_lock()
Return a local object.
ThreadGrp * clone(int nthread=-1)
Create a ThreadGrp like the current one.
int wait_threads()
Wait for all the threads to complete.
int start_threads()
Starts the threads running.
The base class for all reference counted objects.
Definition: ref.h:194
A template class that maintains references counts.
Definition: ref.h:332
The ThreadGrp abstract class provides a means to manage separate threads of control.
Definition: thread.h:92
virtual ThreadGrp * clone(int nthread=-1)
Create a ThreadGrp like the current one.
virtual Ref< ThreadLock > new_lock()=0
Return a local object.
int nthread() const
The number of threads that will be run by start_thread.
Definition: thread.h:111
virtual void add_thread(int threadnum, Thread *thread)
Assigns a Thread object to each thread.
virtual void add_thread(int threadnum, Thread *thread, int priority)
Like add_thread(threadnum, thread), but assign a priority that the thread is to use.
virtual int start_threads()=0
Starts the threads running.
virtual int wait_threads()=0
Wait for all the threads to complete.
Acquire a lock on creation and release it on destruction.
Definition: thread.h:60
ThreadLockHolder(const Ref< ThreadLock > &l)
Acquires the lock.
Definition: thread.h:65
void unlock()
Release the lock before the DTOR is called, if it is still held.
Definition: thread.h:70
~ThreadLockHolder()
Releases the lock if it is still held.
Definition: thread.h:74
void lock()
Acquire the lock once more.
Definition: thread.h:72
The ThreadLock abstract class provides mutex locks to be used in conjunction with ThreadGrp's.
Definition: thread.h:44
virtual void unlock()=0
Release the lock.
virtual void lock()=0
Obtain the lock.
The Thread abstract class defines an interface which must be implemented by classes wishing to be run...
Definition: thread.h:79
virtual void run()=0
This is called with the Thread is run from a ThreadGrp.

Generated at Wed Feb 28 2024 16:35:32 for MPQC 2.3.1 using the documentation package Doxygen 1.9.6.