src/engine/thread_obj.cpp

Go to the documentation of this file.

#include <map>
#include <vector>
#include <string.h>
#include <malloc.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include "tools/assert.h"
#include "tools/log.h"

#include "thread_obj.h"

pthread_mutex_t mgmt_lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;

std::map<pthread_t, ThreadObj*> thread_map;

ThreadObj::ThreadObj(std::string n) : lock(RECURSIVE_MUTEX), 
        has_started(false), ask_stop(false), stopped(true), thread_running(false), id(0)
{
        lock.Lock();
        name = n;
        lock.Unlock();

        log(LogDebug, "Starting thread %p : %s", this, n.c_str());
}

ThreadObj::~ThreadObj()
{
        //This would trigger a race condition...
        //SetAskStop(true);
        //while(!GetStopped())
        //      usleep(50000);

}

void ThreadObj::Start()
{
        lock.Lock();
        pthread_mutex_lock(&mgmt_lock);
        thread_running = true;
        int r = pthread_create(&id, NULL, StartThread, (void*)this);
        thread_map.insert(std::make_pair(id, this));
        if(r != 0)
                log(LogError, "Could not start thread: %s", strerror(r));
        pthread_mutex_unlock(&mgmt_lock);
        lock.Unlock();
}

void *ThreadObj::StartThread(void* arg)
{
        ThreadObj* thr = static_cast<ThreadObj*>(arg);
        thr->OnStart();

        thr->lock.Lock();
        thr->stopped = false;
        thr->ask_stop = false;
        thr->has_started = true;
        thr->lock.Unlock();

        thr->Main();

        thr->lock.Lock();
        thr->stopped = true;
        thr->ask_stop = false;
        thr->OnStop();
        thr->lock.Unlock();

        pthread_exit(NULL);
        return NULL;
}

void ThreadObj::Kill()
{
        lock.Lock();
        pthread_mutex_lock(&mgmt_lock);
        log(LogDebug, "Killing thread %p : %s", this, name.c_str());
        stopped = true;
        ask_stop = false;

        std::map<pthread_t, ThreadObj*>::iterator it = thread_map.find(id);
        if(it != thread_map.end())
                thread_map.erase(it);

        int r = pthread_cancel(id);

        if(r != 0)
                log(LogError, "Unable to cancel thread %s", strerror(r));
        pthread_mutex_unlock(&mgmt_lock);
        lock.Unlock();
}

ThreadObj* GetCurrentThread()
{
        pthread_mutex_lock(&mgmt_lock);
        pthread_t current_id = pthread_self();

        std::map<pthread_t, ThreadObj*>::iterator it = thread_map.find(current_id);
        if(it != thread_map.end())
        {
                ThreadObj* th = it->second;
                pthread_mutex_unlock(&mgmt_lock);
                return th;
        }
        pthread_mutex_unlock(&mgmt_lock);
        return NULL;
}

bool ThreadObj::GetAskStop()
{
        lock.Lock();
        bool ret = ask_stop;
        lock.Unlock();
        return ret;
}

bool ThreadObj::GetStopped()
{
        lock.Lock();
        bool ret = stopped && has_started;
        lock.Unlock();
        return ret;
}

void ThreadObj::Stop()
{
        lock.Lock();
        ask_stop = true;
        lock.Unlock();

        while(!GetStopped())
                usleep(5000);


        pthread_mutex_lock(&mgmt_lock);
        if(!thread_running)
        {
                pthread_mutex_unlock(&mgmt_lock);
                return;
        }

        thread_running = false;
        pthread_join(id, NULL);

        std::map<pthread_t, ThreadObj*>::iterator it = thread_map.find(id);
        if(it != thread_map.end())
                thread_map.erase(it);

        pthread_mutex_unlock(&mgmt_lock);
}

---