Chapter 10, Threads

void foo(int x)
{
    for(int e=0;e<5;e++)
    {
        sleep(1);
        write("Hello from thread "+x+".\n");
    }
}

int main()
{
    thread_create(foo, 2);
    thread_create(foo, 3);
    foo(1);
}

Accessing unlocked data

Look at this code:

void mapadd(mapping m, int i, int j)
{
    if(map[i])
        map[i]+=({j});
    else
        map[i]=({j});
}

This is quite harmless as long as it is only used from one thread at a time, but if two threads call it it at the same time, there is a slight chance that both threads will discover that map[i] is zero and both threads will then do map[i]=({j}); and one value of j will be lost. This type of bug can be extremely hard to debug. The above problem can be solved with the help of Mutexes and Condition variables. Mutexes are basically a way to keep other threads out while a task is being performed. Conditions, or condition variables, are used to inform other threads that they don't have to wait any longer. Pike also provides two different kinds of pipelines to send data from one thread to another, which makes it very simple to write threaded programs. Let's look at an example:

#!/usr/local/bin/pike
import Thread;			// We need fifos
inherit Fifo;			// Fifo used to supply workers
inherit Fifo : ended;		// Fifo used to wait for workers

void worker(string lookfor)
{
    while(string file=Fifo::read())
    {
        int linenum=1;
        object o=Stdio.FILE(file,"r");
        while(string line=o->gets())
        {
            if(search(line, lookfor) >=0)
                write(sprintf("%s:%d: %s\n",file, linenum, line));

            linenum++;
        }
    }
    ended::write(0);
}

int main(int argc, array(string) argv)
{
    for(int e=0;e<4;e++)          // Start workers
        thread_create(worker,argv[e]);
    for(int e=2;e<argc;e++)       // Feed workers
        Fifo::write(argv[1]);
    for(int e=0;e<4;e++)          // Tell workers to die
        Fifo::write(0);
    for(int e=0;e<4;e++)          // Wait for workers to die
        ended::read();
    exit(0);
}

This is an example of a simple grep-like program. It looks for the string given as first argument to the program in the files given as the rest of the arguments. Don't worry if you do not understand it yet. Read the descriptions of the functions and classes below and come back and read this example again.

Deadlocks

Deadlocks arise when two threads are waiting for each other to do something. This bug can often arise when several threads need access to a number of resources such as files or other I/O devices. What may happen is that one thread has locked device #1 and is trying to lock device #2 while another thread has locked device #2 and is trying to lock device #1. This type of bug is generally easier to find, but may require a lot of work to fix.

10.2 Threads reference section

CLASS

Thread.Mutex - mutex locks

DESCRIPTION

Thread.Mutex is a pre-compiled Pike program that implements mutual exclusion locks. Mutex locks are used to prevent multiple threads from simultaneously execute sections of code which access or change shared data. The basic operations for a mutex is locking and unlocking, if a thread attempts to lock an already locked mutex the thread will sleep until the mutex is unlocked.

NOTE

Mutex locks are only available on systems with POSIX or UNIX threads support.

In POSIX threads, mutex locks can only be unlocked by the same thread that locked them. In Pike any thread can unlock a locked mutex.

EXAMPLE

/* This simple program can be used to exchange data between two
 * programs. It is similar to Thread.Fifo, but can only hold one
 * element of data.
 */

inherit Thread.Mutex : r_mutex;
inherit Thread.Mutex : w_mutex;
object r_lock=r_mutex::lock();
object w_lock;
mixed storage;

void write(mixed data)
{
    w_lock=w_mutex::lock();
    storage=data;
    destruct(r_lock);
}

mixed read()
{
    mixed tmp;
    r_lock=r_mutex::lock();
    tmp=storage;
    storage=0;
    destruct(w_lock);
    return tmp;
}

METHOD

Thread.Mutex.lock - lock the mutex

SYNTAX

object lock();

DESCRIPTION

This function attempts to lock the mutex, if the mutex is already locked the current thread will sleep until the lock is unlocked by some other thread. The value returned is the 'key' to the lock. When the key is destructed or has no more references the lock will automatically be unlocked. The key will also be destructed if the lock is destructed.

METHOD

Thread.Mutex.trylock - try to lock the mutex

SYNTAX

object trylock();

DESCRIPTION

This function performs the same operation as lock(), but if the mutex is already locked zero will be returned instead of sleeping until the lock is unlocked.

METHOD

Thread.Condition.signal - signal a condition variable

SYNTAX

void signal();

DESCRIPTION

Signal wakes up one of the threads currently waiting for the condition.

BUGS

It sometimes wakes up more than one thread.

METHOD

Thread.Condition.broadcast - signal all waiting threads

SYNTAX

void broadcast();

DESCRIPTION

This function wakes up all threads currently waiting for this condition.

METHOD

Thread.Fifo.create - initialize the fifo

SYNTAX

void create(int size);
object(Thread.Fifo) Thread.Fifo();
object(Thread.Fifo) Thread.Fifo(int size);

DESCRIPTION

The function create() is called when the fifo is cloned, if the optional size argument is present it sets how many values can be written to the fifo without blocking. The default size is 128.

METHOD

Thread.Fifo.write - queue a value

SYNTAX

void write(mixed value);

DESCRIPTION

This function puts a value last in the fifo. If there is no more room in the fifo the current thread will sleep until space is available.

METHOD

Thread.Fifo.read - read a value from the fifo

SYNTAX

mixed read();

DESCRIPTION

This function retrieves a value from the fifo. Values will be returned in the order they were written. If there are no values present in the fifo the current thread will sleep until some other thread writes a value to the fifo.

METHOD

Thread.Fifo.size - return number of values in fifo

SYNTAX

int size();

DESCRIPTION

This function returns how many values are currently in the fifo.

10.3 Threads example