include/amino/thread.h

Go to the documentation of this file.

/*
 * (c) Copyright 2008, IBM Corporation.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#ifndef AMINO_UTIL_THREAD
#define AMINO_UTIL_THREAD

#include <pthread.h>
#include <string>
#include <vector>
#include <stdio.h>

namespace amino {
using namespace std;

class Runnable {
public:
        virtual void* run() = 0;
        virtual ~Runnable() {}
};

class Thread : public Runnable {
    private:
        bool started;
public:
        typedef pthread_t native_handler_type;
        Thread() :
                runner(NULL) {
                threadId = 0;
        }

        Thread(int id) :
                threadId(id), runner(NULL) {
        }

        Thread(string n, Runnable *r = NULL) :
                name(n), runner(r) {
            started = false;
        }

        Thread(Runnable* r) :
                runner(r) {
            started = false;
        }

        template <class F> static void * callFuncObj(void * ob) {
                //call function object
                (*((F*) (ob)))();
                return NULL;
        }

        template <class F> explicit Thread(F& f) {
                pthread_create(&tid, NULL, &callFuncObj<F>, &f);
        started = true;
        }

        virtual void* run() {
                printf("Thread::run()\n");
                return NULL;
        }

        void setRunner(Runnable *r) {
                this->runner = r;
        }

        void start() {
                pthread_create(&tid, NULL, Thread::execute, this);
        }

        native_handler_type native_handle() {
                return tid;
        }

        void setName(string name) {
                this->name = name;
        }

        string getName() {
                return name;
        }

        void join() {
                pthread_join(tid, NULL);
        }

        bool joinable() const {
                return true;
        }

        void detach() {
                pthread_detach(tid);
        }

        virtual ~Thread() {
        //if(started)
            //pthread_destroy
        }

private:
        static void* execute(void* arg) {
                Thread* thread = (Thread*)arg;
                if (thread->runner != NULL) {
                        return thread->runner->run();
                } else {
                        return thread->run();
                }
        }

protected:
        int threadId;
        pthread_t tid;
        string name;
private:
        Runnable* runner;
};
}
#endif

---