threadmanager.h

一些unix下的c/c++的util包

#ifndef DEFAULT_THREAD_MANAGER


#include <time.h>
#include <errno.h>
#include <pthread.h>
#include <semaphore.h>
namespace nlkit
{
class unix_thread_manager
{
public:
    struct thread_obj_base
    {
        virtual ~thread_obj_base() {};
        virtual void operator()() = 0;
    };

    static void sleep(int nMillisecs)
    {
        struct timespec interval, remainder;
        interval.tv_sec = 0;
        interval.tv_nsec = nMillisecs*1000000;
        nanosleep( &interval, &remainder );
    }

    static void create_thread(thread_obj_base & obj)
    {
        pthread_t pt;
        int retCode = pthread_create(&pt, NULL,
            unix_thread_manager::ThreadProc, &obj);
    }

    class critical_section
    {
         critical_section & operator = ( const critical_section & Not_Implemented);
         critical_section( const critical_section & From);
    public:
         critical_section() { pthread_mutex_init(&mutex, 0); }
         ~critical_section() { pthread_mutex_destroy(&mutex); }
         void Lock() { pthread_mutex_lock(&mutex); }
         void Unlock() { pthread_mutex_unlock(&mutex); }
    private:
         pthread_mutex_t mutex;
    };

    // automatic locking/unlocking of a resource
    class auto_lock_unlock
    {
        auto_lock_unlock operator=( auto_lock_unlock & Not_Implemented);
        auto_lock_unlock( const auto_lock_unlock & Not_Implemented);
    public:
        auto_lock_unlock( critical_section & cs) : m_cs( cs) { m_cs.Lock(); }
        ~auto_lock_unlock() { m_cs.Unlock(); }
    private:
        critical_section & m_cs;
    };

private:
    static void * ThreadProc( void * lpData)
    {
        thread_obj_base * pThread = (thread_obj_base *)lpData;
        ( *pThread)();
        return lpData;
    }
};
#define DEFAULT_THREAD_MANAGER unix_thread_manager
}

#endif //DEFAULT_THREAD_MANAGER