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.
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 141 of file Thread.c.

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

_Thread()

Class * _Thread

(

void

)

Definition at line 206 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);
 
  // https://stackoverflow.com/a/4760758
  // 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 81 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 90 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 104 of file Thread.c.

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

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 187 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 113 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 131 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 150 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 169 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 75 of file Thread.c.