Thread.c File Reference

#include <assert.h>
#include <errno.h>
#include <signal.h>
#include <stdlib.h>
#include <pthread.h>
#include "Thread.h"

Go to the source code of this file.

Macros
#define	_Class   _Thread

Functions
static void	_kill (Thread *self, int signal)
Class *	_Thread (void)
static void	cancel (Thread *self)
static Object *	copy (const Object *self)
static Thread *	currentThread (void)
static void	dealloc (Object *self)
static void	detach (Thread *self)
static Thread *	init (Thread *self)
static void	initialize (Class *clazz)
static Thread *	initWithFunction (Thread *self, ThreadFunction function, ident data)
static void	join (Thread *self, ident *status)
static ident	run (ident obj)
	Wraps the user-specified ThreadFunction, providing cleanup. More...
static void	start (Thread *self)

Variables
static __thread Thread *	_currentThread

Macro Definition Documentation

_Class

#define _Class   _Thread

Definition at line 33 of file Thread.c.

Function Documentation

_kill()

static void _kill ( Thread *  self, int  signal  )

static

Definition at line 140 of file Thread.c.

                                            {
 
    int err = pthread_kill(*((pthread_t *) self->thread), signal);
    assert(err == 0);
}

_Thread()

Class * _Thread

(

void

)

Definition at line 205 of file Thread.c.

                     {
    static Class *clazz;
    static Once once;
 
    do_once(&once, {
        clazz = _initialize(&(const ClassDef) {
            .name = "Thread",
            .superclass = _Object(),
            .instanceSize = sizeof(Thread),
            .interfaceOffset = offsetof(Thread, interface),
            .interfaceSize = sizeof(ThreadInterface),
            .initialize = initialize,
        });
    });
 
    return clazz;
}

cancel()

static void cancel ( Thread *  self )

static

Definition at line 64 of file Thread.c.

                                 {
 
    assert(self->isCancelled == false);
 
    // int err = pthread_cancel(*((pthread_t *) self->thread));
    // assert(err == 0);
 
    self->isCancelled = true;
}

copy()

static Object * copy ( const Object *  self )

static

See also

Object::copy(const Object *)

Definition at line 40 of file Thread.c.

                                        {
    return NULL;
}

currentThread()

static Thread * currentThread ( void  )

static

Definition at line 80 of file Thread.c.

                                   {
 
    return _currentThread;
}

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 47 of file Thread.c.

                                  {
 
    Thread *this = (Thread *) self;
 
    assert(this->isExecuting == false);
 
    free(this->thread);
 
    super(Object, self, dealloc);
}

detach()

static void detach ( Thread *  self )

static

Definition at line 89 of file Thread.c.

                                 {
 
    assert(self->isDetached == false);
 
    int err = pthread_detach(*((pthread_t *) self->thread));
    assert(err == 0);
 
    self->isDetached = true;
}

init()

static Thread * init ( Thread *  self )

static

Definition at line 103 of file Thread.c.

                                  {
 
    return $(self, initWithFunction, NULL, NULL);
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 186 of file Thread.c.

                                     {
 
    ((ObjectInterface *) clazz->interface)->copy = copy;
    ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
 
    ((ThreadInterface *) clazz->interface)->cancel = cancel;
    ((ThreadInterface *) clazz->interface)->currentThread = currentThread;
    ((ThreadInterface *) clazz->interface)->detach = detach;
    ((ThreadInterface *) clazz->interface)->init = init;
    ((ThreadInterface *) clazz->interface)->initWithFunction = initWithFunction;
    ((ThreadInterface *) clazz->interface)->join = join;
    ((ThreadInterface *) clazz->interface)->kill = _kill;
    ((ThreadInterface *) clazz->interface)->start = start;
}

initWithFunction()

static Thread * initWithFunction ( Thread *  self, ThreadFunction  function, ident  data  )

static

Definition at line 112 of file Thread.c.

                                                                                   {
 
    self = (Thread *) super(Object, self, init);
    if (self) {
        self->function = function;
        self->data = data;
 
        self->thread = calloc(1, sizeof(pthread_t));
        assert(self->thread);
    }
 
    return self;
}

join()

static void join ( Thread *  self, ident *  status  )

static

Definition at line 130 of file Thread.c.

                                              {
 
    int err = pthread_join(*((pthread_t *) self->thread), status);
    assert(err == 0);
}

run()

static ident run ( ident  obj )

static

Wraps the user-specified ThreadFunction, providing cleanup.

Definition at line 149 of file Thread.c.

                            {
 
    Thread *self = _currentThread = (Thread *) obj;
 
    self->isExecuting = true;
 
    ident ret = self->function(self);
 
    self->isFinished = true;
 
    self->isExecuting = false;
 
    return ret;
}

start()

static void start ( Thread *  self )

static

Definition at line 168 of file Thread.c.

                                {
 
    assert(self->function);
 
    assert(self->isCancelled == false);
    assert(self->isDetached == false);
    assert(self->isExecuting == false);
    assert(self->isFinished == false);
 
    int err = pthread_create(self->thread, NULL, run, self);
    assert(err == 0);
}

Variable Documentation

_currentThread

__thread Thread* _currentThread

static

Definition at line 74 of file Thread.c.