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>

namespace nidas { namespace util {

class Runnable {
public:

    virtual ~Runnable() {}
    virtual int run() throw(Exception) = 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);

    Thread(const Thread& x);

    virtual ~Thread();

    virtual void start() throw(Exception);

    virtual int join() throw(Exception);

    virtual void kill(int sig) throw(Exception);

    virtual void cancel() throw(Exception);

    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) throw(Exception);
    bool setRealTimeFIFOPriority(int val) throw(Exception);
    bool setNonRealTimePriority() throw(Exception);

    void setThreadScheduler(enum SchedPolicy policy, int priority) throw(Exception);

    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) throw(Exception);

    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;

    bool _interrupted;

    bool _cancel_enabled;

    bool _cancel_deferred;

    pthread_attr_t _thread_attr;

    Exception* _exception;

    bool _detached;

    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);

};

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 () throw(Exception)
        {
            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