Thread.h

Go to the documentation of this file.

// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 4; tab-width: 4; -*-
// vim: set shiftwidth=4 softtabstop=4 expandtab:
/*
 ********************************************************************
 ** NIDAS: NCAR In-situ Data Acquistion Software
 **
 ** 2006, Copyright University Corporation for Atmospheric Research
 **
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU General Public License as published by
 ** the Free Software Foundation; either version 2 of the License, or
 ** (at your option) any later version.
 **
 ** This program is distributed in the hope that it will be useful,
 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ** GNU General Public License for more details.
 **
 ** The LICENSE.txt file accompanying this software contains
 ** a copy of the GNU General Public License. If it is not found,
 ** write to the Free Software Foundation, Inc.,
 ** 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 **
 ********************************************************************
*/
 
#ifndef NIDAS_UTIL_THREAD_H
#define NIDAS_UTIL_THREAD_H
 
#include <csignal>
 
#include "Exception.h"
#include "ThreadSupport.h"
 
#include <string>
#include <map>
#include <set>
#include <atomic>
 
namespace nidas { namespace util {
 
class Runnable {
public:
 
    virtual ~Runnable() {}
    virtual int run() = 0;
 
    virtual void interrupt() = 0;
 
    virtual bool isInterrupted() const = 0;
 
protected:
    void testCancel() const { ::pthread_testcancel(); }
 
    virtual bool amInterrupted() const;
};
 
class Thread : public Runnable {
 
public:
    static Thread *currentThread ();
 
    static pthread_t currentThreadId ();
 
    static Thread *lookupThread(pthread_t id);
 
    static const std::string& currentName ()
    {
        Thread *thr = currentThread ();
        if (thr) return thr->getName();
        return unknownName;
    }
 
    enum runStatus { RUN_CANCELED = -1, RUN_OK = 0, NOT_RUNNING = 1, RUN_EXCEPTION = 2 };
 
public:
 
    Thread(const std::string& name, bool detached=false);
 
    virtual ~Thread();
 
    virtual void start();
 
    virtual int join();
 
    virtual void kill(int sig);
 
    virtual void cancel();
 
    virtual void interrupt();
 
    virtual bool isInterrupted() const
    { 
        Synchronized sync(_mutex);
        return _interrupted; 
    }
 
    virtual bool isRunning() const
    { 
        Synchronized sync(_mutex);
        return _running;
    }
 
    virtual bool isJoined() const
    { 
        return getId() == 0;
    }
 
    virtual bool isDetached() const
    { 
        return _detached; 
    }
 
    bool isCancelEnabled() const;
 
    bool isCancelDeferred() const;
 
    const std::string& getName() const throw();
 
    const std::string& getFullName() throw();
 
    static std::string getPolicyString(int policy);
 
    enum SchedPolicy { NU_THREAD_OTHER=SCHED_OTHER,
        NU_THREAD_FIFO=SCHED_FIFO, NU_THREAD_RR=SCHED_RR};
 
    bool setRealTimeRoundRobinPriority(int val);
 
    bool setRealTimeFIFOPriority(int val);
 
    bool setNonRealTimePriority();
 
    void setThreadScheduler(enum SchedPolicy policy, int priority);
 
    void blockSignal(int);
 
    void unblockSignal(int);
 
    static int test(int argc, char** argv);
 
protected:
    void setCancelEnabled(bool val);
 
    void setCancelDeferred(bool val);
 
    pthread_t getId() const
    {
        Synchronized sync(_mutex);
        return _id;
    }
 
private:
 
    static void* thr_run(void *me);
    static void* thr_run_detached(void *me);
    static void thr_cleanup(void *me);
    static void thr_cleanup_delete(void *me);
    static void thr_add_sig(int sig);
 
    virtual void signalHandler(int /* sig */, siginfo_t* /* si */)
    {
        _interrupted = true;
    }
 
    static std::string unknownName;
 
    virtual int pRun ();
 
    void setThreadSchedulerNolock(enum SchedPolicy policy, int priority);
 
    void setThreadSchedulerNolock();
 
    void makeFullName();        // add thread id to name once we know it
 
    void registerThread();
 
    void unregisterThread();
 
    mutable Mutex _mutex;
 
    std::string _name;
 
    std::string _fullname;
 
    pthread_t _id;
 
    bool _running;
 
    std::atomic<bool> _interrupted;
 
    bool _cancel_enabled;
 
    bool _cancel_deferred;
 
    Exception* _exception;
 
    bool _detached;
    SchedPolicy _policy;
    int _priority;
 
    sigset_t _blockedSignals;
 
    sigset_t _unblockedSignals;
 
    static void sigAction(int sig, siginfo_t* si,void* vptr);
 
    void unsetId()
    {
        Synchronized sync(_mutex);
        _id = 0;
    }
 
    Thread& operator=(const Thread& x) = delete;
    Thread(const Thread& x) = delete;
 
};
 
class DetachedThread : public Thread {
public:
    DetachedThread(const std::string& name) : Thread(name,true) {}
};
 
class ThreadRunnable : public Thread
{
public:
    ThreadRunnable (const std::string& name, Runnable* target = 0) :
        Thread (name),
        _target(target)
    {}
 
    void interrupt() {
        if (_target) _target->interrupt();
    }
 
    int
    run ()
    {
        if (_target)
            return _target->run();
        return NOT_RUNNING;
    }
 
private:
    Runnable *_target;
 
    ThreadRunnable(const ThreadRunnable&);
 
    ThreadRunnable& operator=(const ThreadRunnable&);
 
};
 
class ThreadJoiner: public DetachedThread
{
public:
    ThreadJoiner(Thread* thrd);
 
    ~ThreadJoiner();
 
    int run() throw();
private:
    Thread* _thread;
 
    ThreadJoiner(const ThreadJoiner&);
 
    ThreadJoiner& operator=(const ThreadJoiner&);
};
 
typedef ThreadRunnable DefaultThread;
 
}}  // namespace nidas namespace util
 
#endif