Jan Kończak

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
===== Threads =====

A process can run multiple threads – multiple flows of control.
\\
In general, the threads share all resources (such as memory or open files).
\\
Each thread uses a separate stack, and obviously has its own state of the CPU
registers. A limited set of properties might also be specific to a thread
(e.g., signal mask, CPU affinity).

<small>
Since 2012 the C and C%%+%%+ languages include API for concurrency, including
threads. However, it is very generic, so that it can be implemented in all
operating systems. 
^ ^ POSIX ^ C ^ C%%+%%+ ^
|create a new thread|''pthread_create''|''thrd_create''|''std::thread'' constructor|
|join a thread|''pthread_join''|''thrd_join''|''std::thread::join''|
|detach a thread|''pthread_detach''|''thrd_detach''|''std::thread::detach''|
|exit from a thread|''pthread_exit''|''thrd_exit''|—|
|send signal to a specific thread|''pthread_kill''|—|—|
</small>

A process always starts with a single thread called the main thread.
\\
When the main thread returns from ''main'' function, or when any thread
calls ''exit'' function, all threads are forcefully terminated.

===== pthreads =====

The POSIX standard defines an API for threads called
**[[https://en.wikipedia.org/wiki/Pthreads|pthreads]]**.
While each operating system has its own implementation of threads, virtually
any Unix-like system implements the POSIX Threads API.
\\
<small>Linux implementation of threads is called
[[https://en.wikipedia.org/wiki/Native_POSIX_Thread_Library|NPTL]].
Apart from the standard pthread functions, it offers several Linux-specific
functions (which names end with ''_np'' to indicate non-portability).</small>

**To compile any program that uses pthreads, one had to add ''-pthread'' option
upon invoking compiler and linker.**
\\
This changed since version 2.34 of glibc, that moved POSIX thread routines to
standard C library (libc).

==== Creating a thread ====

To start a new thread, one must point to the function that will be executed
by the thread.
\\
The function must take a pointer to arbitrary data as an argument and return an
pointer to arbitrary data((To specify a pointer without specifying the type of
underlying data one has to use ''void *''.)):
<code c>
void * start_routine (void * argument){
  …
  return some_pointer;
}
</code>
<small>In C such function is of type ''void *(*)(void *)'', and a variable called
''func'' of this type should be declared as ''void *(*func)(void *)''.</small>
\\
A new thread will get an identifier of type ''pthread_t'' that can be used later
on to refer to the thread.

The function starting a new thread has the following syntax:
\\
<html><span style="float:right"><small>Needs header:<br><code>pthread.h</code></small></span>
<a href="https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_create.html"></html>
''int **pthread_create**(pthread_t *restrict //threadIdentifier//,''  \\
''                   const pthread_attr_t *restrict //attr//,''  \\
''                   void *(*//start_routine//)(void *),''  \\
''                   void *restrict //arg//);''\\
<html></a></html>
It will write the thread identifier to the variable pointed by ''//threadIdentifier//'',
start a new thread and run ''//start_routine//(//arg//)'' in it. If the ''//attr//''
argument is not NULL, thread attributes will be set before starting the thread.

<html><div style="line-height:1em"></html>
++++An example of creating a thread and passing it some data|
<code c>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

struct myStruct { int i; char s[16]; };

// function to be run by a thread; it must accept and return a 'void *'
void *func(void *rawArg) {
  struct myStruct *arg = rawArg;
  printf("%d %s\n", arg->i, arg->s);
  free(arg);
  return NULL;
}

int main() {
  pthread_t ti; // pthread_t is a type that stores thread identifiers ('long unsigned int' in Linux) 
  
  // to pass several data to a thread, a structure is created on heap
  struct myStruct *t1_arg = malloc(sizeof(struct myStruct));
  t1_arg->i = 42; strcpy(t1_arg->s, "foo baz bar");
  
  // the following line creates a new thread and runs func(t1_arg) in the thread.
  pthread_create(&ti, NULL, func, t1_arg);
  
  // terminating the main thread (or any other) with pthread_exit does not terminate the process
  pthread_exit(NULL);
}
</code>
++++
<html></div></html>

==== Caring for a thread ====

Just like a child process is remembered by the operating system until the parent
process reaps it, a thread that has terminated is remembered by the operating
system until another thread **join**s it. Alternatively, a thread can be
explicitly **detach**ed so that it is immediately reaped upon termination and
cannot be joined anymore.

<small>
By default, a thread starts in joinable state. One can create a set of attributes
(using ''pthread_attr_init'' and ''pthread_attr_setdetachstate'') that tells the
OS to create a thread in the detached state.
</small>

To join a thread and collect its result one has to call the function:
\\
<html><span style="float:right"><small>Needs header: <code>pthread.h</code></small></span>
<a href="https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_join.html"></html>
''int **pthread_join**(pthread_t //thread//, void %%**%%//value_ptr//);''
<html></a></html>
\\
Calling the ''pthread_join'' waits until the thread ''//thread//'' terminates
and writes its return value to the ''void *'' pointer pointed by ''//value_ptr//''.
The ''//value_ptr//'' can be NULL, and then the return value is discarded.

<html><div style="line-height:1em"></html>
++++An example code that creates 3 threads and joins them, collecting their result.|
<code c>
#include <pthread.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

// this just does computation, there's nothing about threads here
void monteCarloPi(uint64_t *hit, uint64_t *miss) {
  struct timespec ts;
  clock_gettime(CLOCK_REALTIME, &ts);
  srand(ts.tv_nsec);
  for (int i = 0; i < 1e6; ++i) {
    double x = rand() / (double)RAND_MAX;
    double y = rand() / (double)RAND_MAX;
    if ((x*x + y*y) < 1) (*hit)++;
    else                 (*miss)++;
  }
}

struct theResult { uint64_t hit; uint64_t miss; };

void *runPi(void *arg) {
  // preparing the return value - a structure 'theResult'
  struct theResult *ret = malloc(sizeof(struct theResult));
  
  // filling it with data
  ret->hit = ret->miss = 0;
  monteCarloPi(&ret->hit, &ret->miss);
  
  // returning pointer to memory allocated on heap
  return ret;
}

int main() {
  pthread_t ti[3];
  uint64_t hit = 0, miss = 0;
  for (int i = 0; i < 3; ++i)
    pthread_create(ti + i, NULL, runPi, NULL);
  monteCarloPi(&hit, &miss);
  
  for (int i = 0; i < 3; ++i) {
    // create a variable that will store the location of the result
    struct theResult *result;
    
    // wait until thread ti[i] exits, and write its return value to result
    pthread_join(ti[i], (void **)&result);
    
    // use the result 
    hit += result->hit;
    miss += result->miss;
    
    // free the memory
    free(result);
  }
  
  printf("%f\n", 4. * hit / (hit + miss));
  return 0;
}
</code>
++++
<html></div></html>


To detach a thread one has to call the function:
\\
<html><span style="float:right"><small>Needs header: <code>pthread.h</code></small></span>
<a href="https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_detach.html"></html>
''int **pthread_detach**(pthread_t //thread//);''
<html></a></html>
\\
The ''pthread_detach'' function returns without waiting. The value returned by
the detached thread will be discarded.
\\
A thread can detach itself (i.e. call ''pthread_detach(pthread_self());''), but
typically the thread that spawned it calls the detach.

<html><div style="line-height:1em"></html>
++++An example code that creates a thread and detaches it.|
<code c>
#ifdef __GNUC__      // whenever GNU Compiler or compatible is detected,
#define _GNU_SOURCE  // enable GNU Compiler extensions.
#endif
#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

void *buzzer(void *arg) {
#ifdef _GNU_SOURCE // when GNU Compiler extensions are available,
  pthread_setname_np(pthread_self(), "buzzer"); // assign a name for the thread
#endif
  int i = 0;
  while (1) {
    usleep(1e5);
    fprintf(stderr, "%06d BZZZZZTT\n", ++i);
  }
}

void usr1(int num) {
  signal(SIGUSR1, SIG_DFL);
  char name[33] = "USR1 received by ";
#ifdef _GNU_SOURCE
  pthread_getname_np(pthread_self(), name + 17, 16);
#endif
  int len = strlen(name); name[len] = '\n';
  write(STDERR_FILENO, name, len + 1);
  pthread_exit(NULL); // terminate this thread
}

int main() {
  // create a thread
  pthread_t ti;
  pthread_create(&ti, NULL, buzzer, NULL);
  
  // and tell the operating system that the thread will never be joined
  pthread_detach(ti);
  
  sleep(1);
  signal(SIGUSR1, usr1);     // notice that threads share signal handlers
  pthread_kill(ti, SIGUSR1); // sends a signal to a specified thread
  sleep(1);
  return 0;
}
</code>
++++
<html></div></html>

<small>
POSIX offers a mechanism called //cancellation//. That is, one can send to a
thread a cancellation request using the
''[[https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_cancel.html|pthread_cancel]]''
function. Each thread can select is behaviour on receiving such request using the
''[[https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_setcancelstate.html|pthread_setcancelstate]]''
and
''[[https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_setcancelstate.html|pthread_setcanceltype]]''
functions. One may either allow or disallow cancalling a thread, and one may
choose whether the cancallation should ouccur immediatly after a request, or
at the next cancallation point. Cancellation points are the execution points
of several pthread functions, among which notably 
''[[https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_setcancelstate.html|pthread_testcancel]]''
is there just to this end.
Once the thread complies to the cancellation request, it roughly does the same
actions as if ''pthread_exit(PTHREAD_CANCELED)'' was called.
The cancellation mechanism allows deferring thread termination until a logically consistent state (e.g. of data shared with other threads) is reached.
</small>

=== Exercises ===

~~Exercise.#~~
In the main thread create a new thread, join it and then return from main.
\\
In the newly created thread write ''Hello World'' to the standard output.

~~Exercise.#~~
Remove the code you wrote for the previous exercise the ''pthread_join'' and
re-run the code. What has changed in the behaviour of the program?

~~Exercise.#~~
In the main thread create 10 new threads, passing to each of them an ordinal
number. Then, join each thread and exit.
\\
In the newly created threads write the number to the standard output.

~~Exercise.#~~
Add to the program from the previous exercise a global variable. In each thread
read the variable and increment it. Output the obtained value together with 
the ordinal number, and return it from the thread entry routine.
In the main thread, collect the returned numbers and display them.

===== Thread-specific data, thread local storage [extra] =====

In C, data items can have different storage duration and different linkage.
Until C11, there existed only static, automatic or allocated storage durations.
Roughly:
\\
 • static = global variables and static variables defined inside functions,
\\
 • automatic = items on stack, automatically allocated inside functions ('local variables'),
\\
 • allocated = items on heap, explicitly allocated and freed.
\\
None of these cover a case when one wants a static ("global") variable with
a separate value for each thread.
Such storage duration is called [[https://en.wikipedia.org/wiki/Thread-local_storage|thread local]]
and a coupe of ways to create thread-local items are presented in this section.

==== POSIX Thread-specific data ====

One can create //keys// (that may be understood as identifiers of variables) and
then associate, for each thread separately, a value for a key.
To this end the following functions can be used:
\\
<html><span style="float:right"><small>Need header:<br><code>pthread.h</code></small></span>
<a href="https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_key_create.html"></html>
''int **pthread_key_create**(pthread_key_t *//key//, void (*//destructor//)(void*))''
<html></a></html>
\\
<html><a href="https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_setspecific.html"></html>
''int **pthread_setspecific**(pthread_key_t //key//, const void *//value//)''
\\
''void %%*%%**pthread_getspecific**(pthread_key_t //key//)''
<html></a></html>
\\
Each key is initially associated with a ''NULL'' for each thread.

<html><div style="line-height:1em"></html>
++++An example code that creates a key, stores and retrieves the value from two threads.|
<code c>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

pthread_key_t mySpecificVal;

void printMine() {
  printf("I have: %s\n", (char *)pthread_getspecific(mySpecificVal));
}

void *routine(void *arg) {
  char *text = malloc(4);
  strcpy(text, "baz");
  pthread_setspecific(mySpecificVal, text);
  printMine();
  return NULL;
}

int main() {
  char *text = malloc(4);
  strcpy(text, "foo");

  pthread_key_create(&mySpecificVal, free);
  pthread_setspecific(mySpecificVal, text);

  pthread_t ti;
  pthread_create(&ti, NULL, routine, NULL);
  pthread_join(ti, NULL);

  printMine();
  return 0;
}
</code>
++++
<html></div></html>

==== C thread-local storage ====

Starting with C11, a new storage duration ''_Thread_local'' or
''[[https://en.cppreference.com/w/c/thread/thread_local|thread_local]]''((Until
C23 ''thread_local'' was a macro defined in ''threads.h'', since C23 it
is a keyword with same meaning as the ''_Thread_local'' keyword.)) is defined.
Variables defined with this storage duration have unique value for each thread.
Notice that the ''thread_local'' variables can have initial values (unlike in
POSIX), but there is no way to provide a custom destructor (unlike in POSIX). 



~~META:
language = en
~~
Jan Kończak

User Tools

Site Tools

Page Tools
