Thread.cc

Go to the documentation of this file.

/*
 * Thread.cc
 *
 * Smalltalk like class library for C++
 * Thread wrapper.
 *
 * Copyright (c) 2003-05 Milan Cermak
 */
/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include <stdio.h>
#include <unistd.h>

#include <stlib/os/Thread.h>
#include <stlib/Array.h>
#include <stlib/Iterator.h>
#include <stlib/Set.h>
#include <stlib/String.h>
#include <stlib/NotFoundError.h>

using namespace OS;

Set Thread::threads(5);          // Thread container

Thread::Thread(Callback<void> *receiver)
{
    finalizeThreads();
    // Nainicializujeme podminku behu vlakna a mutex
    pthread_mutex_init(&mutVar, NULL);
    pthread_cond_init(&runCond, NULL);
    // Nastavime vykonnou funkci
    _receiver = receiver;
    _arguments = nil;
    // Nastavime priznak beziciho vlakna
    runningThread = false;
}

Thread::~Thread(void)
{
    terminate();
    // Zrusime podminku a mutex
    pthread_cond_destroy(&runCond);
    pthread_mutex_destroy(&mutVar);
    _receiver = nil;
}

/* Class-accessing protocol */
String *Thread::className(void) const
{
    return new String("Thread");
}

Thread *Thread::fork(Callback<void> *receiver)
{
    Thread *thread = new Thread(receiver);
    thread->run();
    return thread;
}

Thread *Thread::fork(Callback<void> *receiver, Array *args)
{
    Thread *thread = new Thread(receiver);
    thread->arguments(args);
    thread->run();
    return thread;
}

/* Prevezme hodnoty od ukoncenych vlaken */
void Thread::finalizeThreads(void)
{
    Set *temp = (Set *) threads.copy();
    for (Iterator* i = temp->iterator(); !i->finished(); i->next()) {
        Thread *th = (Thread *) i->value();
        if (!th->isRunning())
            th->finalize();
    }
    delete temp;
}

void Thread::arguments(Array *args)
{
    _arguments = args;
}

// obnovi beh vlakna
void Thread::resume()
{
    if (runningThread == false) {  // vlakno dosud nebylo vytvoreno
        // zadna akce
        return;
    }
    pthread_cond_signal(&runCond);
}

// pozastavi beh vlakna
void Thread::suspend()
{
    if (runningThread == false) {  // vlakno dosud nebylo vytvoreno
        // zadna akce
        return;
    }
    pthread_cond_wait(&runCond, &mutVar);
}

// Init vytvori pro objekt CThread jeho provadeci tok - vlakno
// tim je staticka metoda ThreadProc, ktere se preda ukazatel this
void Thread::run()
{
    runningThread = true;
    pthread_create(&hThread, NULL, threadProc, this);
    threads.add(this);
}

void Thread::finalize(void)
{
    pthread_join(hThread, NULL);
    runningThread = false;
    try {
        threads.remove(this);
    }
    catch (NotFoundError *ex) {
        /* It doesn't matter if it was there or not. It isn't now for sure. */
    }
}

void Thread::terminate(void)
{
    // zruseni vlakna
    if (runningThread != false) {
        pthread_cancel(hThread);
        // Pockame az vlakno dobehne a odchytime navratovou hodnotu
        finalize();
    }
}

void Thread::yield(void)
{
    sleep(1);
}

/* Testing protocol */
bool Thread::isRunning(void)
{
    return runningThread;
}

// hlavni procedura vlakna
void *Thread::threadProc(void *x)
{
    // pomoci myThread lze pristupovat i k nestatickym clenum tridy
    Thread *myThread = (Thread *) x;

    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
    myThread->runningThread = true;

    myThread->_receiver->executeWith(myThread->_arguments);

    myThread->runningThread = false;

    return NULL;                 // opustenim ThreadProc zanika
                                 // pracovni vlakno objektu Thread
}

---