#include "inspircd_config.h"
#include "base.h"
-class InspIRCd;
-class Thread;
-
-/** The ThreadEngine class has the responsibility of initialising
- * Thread derived classes. It does this by creating operating system
- * level threads which are then associated with the class transparently.
- * This allows Thread classes to be derived without needing to know how
- * the OS implements threads. You should ensure that any sections of code
- * that use threads are threadsafe and do not interact with any other
- * parts of the code which are NOT known threadsafe! If you really MUST
- * access non-threadsafe code from a Thread, use the Mutex class to wrap
- * access to the code carefully.
- */
-class CoreExport ThreadEngine : public Extensible
-{
- protected:
-
- /** Creator instance
- */
- InspIRCd* ServerInstance;
-
- public:
-
- /** Constructor.
- * @param Instance Creator object
- */
- ThreadEngine(InspIRCd* Instance);
-
- /** Destructor
- */
- virtual ~ThreadEngine();
-
- /** Create a new thread. This takes an already allocated
- * Thread* pointer and initializes it to use this threading
- * engine. On failure, this function may throw a CoreException.
- * @param thread_to_init Pointer to a newly allocated Thread
- * derived object.
- */
- virtual void Start(Thread* thread_to_init) = 0;
-
- /** Returns the thread engine's name for display purposes
- * @return The thread engine name
- */
- virtual const std::string GetName()
- {
- return "<pure-virtual>";
- }
-};
-
-/** The Mutex class represents a mutex, which can be used to keep threads
- * properly synchronised. Use mutexes sparingly, as they are a good source
- * of thread deadlocks etc, and should be avoided except where absolutely
- * neccessary. Note that the internal behaviour of the mutex varies from OS
- * to OS depending on the thread engine, for example in windows a Mutex
- * in InspIRCd uses critical sections, as they are faster and simpler to
- * manage.
- */
-class CoreExport Mutex
-{
- protected:
- /** Enable or disable the Mutex. This method has somewhat confusing
- * wording (e.g. the function name and parameters) so it is protected
- * in preference of the Lock() and Unlock() methods which are user-
- * accessible.
- *
- * @param enable True to enable the mutex (enter it) and false to
- * disable the mutex (leave it).
- */
- virtual void Enable(bool enable) = 0;
- public:
-
- /** Constructor.
- */
- Mutex();
-
- /** Enter/enable the mutex lock.
- */
- void Lock() { Enable(true); }
-
- /** Leave/disable the mutex lock.
- */
- void Unlock() { Enable(false); }
-
- /** Destructor
- */
- ~Mutex() { }
-};
+#ifdef WINDOWS
+#include "threadengines/threadengine_win32.h"
+#endif
-class CoreExport ThreadData
-{
- public:
- virtual void FreeThread(Thread* thread) { }
-};
+class ThreadData;
/** Derive from this class to implement your own threaded sections of
* code. Be sure to keep your code thread-safe and not prone to deadlocks
* and race conditions if you MUST use threading!
*/
-class CoreExport Thread : public Extensible
+class CoreExport Thread
{
private:
/** Set to true when the thread is to exit
*/
bool ExitFlag;
+ protected:
+ /** Get thread's current exit status.
+ * (are we being asked to exit?)
+ */
+ bool GetExitFlag()
+ {
+ return ExitFlag;
+ }
public:
/** Opaque thread state managed by threading engine
*/
{
}
- /** If this thread has a Creator set, call it to
- * free the thread
- */
- virtual ~Thread()
- {
- if (state)
- {
- state->FreeThread(this);
- delete state;
- }
- }
+ /* If the thread is running, you MUST join BEFORE deletion */
+ virtual ~Thread();
/** Override this method to put your actual
* threaded code here.
/** Signal the thread to exit gracefully.
*/
- void SetExitFlag(bool value)
+ virtual void SetExitFlag();
+
+ /** Join the thread (calls SetExitFlag and waits for exit)
+ */
+ void join();
+};
+
+
+class CoreExport QueuedThread : public Thread
+{
+ ThreadQueueData queue;
+ protected:
+ /** Waits for an enqueue operation to complete
+ * You MUST hold the queue lock when you call this.
+ * It will be unlocked while you wait, and will be relocked
+ * before the function returns
+ */
+ void WaitForQueue()
{
- ExitFlag = value;
+ queue.Wait();
}
-
- /** Get thread's current exit status.
- * (are we being asked to exit?)
+ public:
+ /** Lock queue.
*/
- bool GetExitFlag()
+ void LockQueue()
{
- return ExitFlag;
+ queue.Lock();
+ }
+ /** Unlock queue.
+ */
+ void UnlockQueue()
+ {
+ queue.Unlock();
+ }
+ /** Unlock queue and wake up worker
+ */
+ void UnlockQueueWakeup()
+ {
+ queue.Wakeup();
+ queue.Unlock();
+ }
+ virtual void SetExitFlag()
+ {
+ queue.Lock();
+ Thread::SetExitFlag();
+ queue.Wakeup();
+ queue.Unlock();
}
};
+class CoreExport SocketThread : public Thread
+{
+ ThreadQueueData queue;
+ ThreadSignalData signal;
+ protected:
+ /** Waits for an enqueue operation to complete
+ * You MUST hold the queue lock when you call this.
+ * It will be unlocked while you wait, and will be relocked
+ * before the function returns
+ */
+ void WaitForQueue()
+ {
+ queue.Wait();
+ }
+ /** Notifies parent by making the SignalFD ready to read
+ * No requirements on locking
+ */
+ void NotifyParent();
+ public:
+ SocketThread(InspIRCd* SI);
+ virtual ~SocketThread();
+ /** Lock queue.
+ */
+ void LockQueue()
+ {
+ queue.Lock();
+ }
+ /** Unlock queue.
+ */
+ void UnlockQueue()
+ {
+ queue.Unlock();
+ }
+ /** Unlock queue and send wakeup to worker
+ */
+ void UnlockQueueWakeup()
+ {
+ queue.Wakeup();
+ queue.Unlock();
+ }
+ virtual void SetExitFlag()
+ {
+ queue.Lock();
+ Thread::SetExitFlag();
+ queue.Wakeup();
+ queue.Unlock();
+ }
+ /**
+ * Called in the context of the parent thread after a notification
+ * has passed through the socket
+ */
+ virtual void OnNotify() = 0;
+};
#endif
projects / user / henk / code / inspircd.git / blobdiff