Making Threads, and Waiting for Them

The total is the same every run and the order of the lines is not. The sum of the squares from one to ten is 385 whatever order the threads ran in, because each thread wrote to its own job. That is what makes this program correct, and Chapter thirty four is the same program written so that it is not.

The order really does change

$ for i in $(seq 20); do ./ten | head -1; done | sort -u > firsts.txt
$ n=$(wc -l < firsts.txt)
$ [ "$n" -gt 1 ] && echo "over twenty runs, $n different threads reached the screen first"
over twenty runs, 3 different threads reached the screen first

Three runs of the same program, and the thread that reached the screen first was not always the same. Nothing in the program decides that. It is the scheduler, and a program that depends on which thread runs first is wrong even when it works.

Counting the threads from outside

The kernel can be asked how many threads a process has while it is running.

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>

static void *wait_a_while(void *unused)
{
    (void)unused;
    sleep(2);
    return NULL;
}

int main(void)
{
    pthread_t id[4];

    for (int i = 0; i < 4; i++) {
        pthread_create(&id[i], NULL, wait_a_while, NULL);
    }
    FILE *f = fopen("/proc/self/status", "r");
    char line[128];
    while (fgets(line, sizeof line, f)) {
        if (strncmp(line, "Threads:", 8) == 0) {
            printf("%s", line);
        }
    }
    fclose(f);
    for (int i = 0; i < 4; i++) {
        pthread_join(id[i], NULL);
    }
    return 0;
}

$ gcc -std=c17 -Wall -Wextra -pthread -o count-threads count-threads.c
$ ./count-threads
Threads:	5

Five: the four that were created and the one that created them. The first thread of a process is a thread like any other, and main runs on it. There is no such thing as a process with no threads.

Passing an argument, and the trap in it

Passing the address of a loop variable to every thread is the commonest thread bug there is.

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <pthread.h>

static void *show(void *argument)
{
    int *n = argument;

    printf("%d ", *n);
    return NULL;
}

int main(void)
{
    pthread_t id[4];

    for (int i = 0; i < 4; i++) {
        pthread_create(&id[i], NULL, show, &i);   /* the SAME address, four times */
    }
    for (int i = 0; i < 4; i++) {
        pthread_join(id[i], NULL);
    }
    printf("\n");
    return 0;
}

$ gcc -std=c17 -Wall -Wextra -pthread -o wrong wrong.c
$ ./wrong
4 4 4 4

Four threads, and every one of them printed the same number. They were all given the address of i, which by the time they ran had reached 4. The fix is what ten.c did: give each thread a pointer to something of its own.

Distinctions that carry marks

What it does not mean

A thread function is not main. It takes one void and returns one void , and returning from it ends only that thread.

pthread_exit in main does not end the process. It ends the first thread and lets the others run on, which is occasionally what you want and usually a surprise.

Joining is not synchronisation between running threads. It waits for one to finish. Two threads that must co-ordinate while both are running need Chapters thirty seven to forty two.

Quick revision

• pthread_create(&id, attr, function, argument) starts a thread; pthread_join(id, &result)

waits for it and collects its value.

• The function takes one void and returns one void . Pass a structure for more.
• Compile with -pthread.
• Life cycle: created, running, blocked, terminated. A terminated thread's record survives until

it is joined or it was detached: the thread version of a zombie.

• The first thread of a process runs main, so a process with four created threads reports five.
• The order in which threads run is the scheduler's business and changes between runs. A

program that depends on it is wrong.

• Never pass the address of the loop variable to every thread: they all see its final value.

Test yourself

1. Which calls create a thread and wait for one? pthread_create and pthread_join.
2. What is the signature of a thread function? It takes one void * and returns one

void *.

1. What happens to a thread nobody joins? Its record and stack stay allocated, like a zombie

process. Join it, or detach it so the library cleans it up when it ends.

1. A process creates four threads. How many does the kernel report and why? Five. The thread

running main is a thread like any other. 5. Four threads are given &i, the address of the loop variable, and all print 4. Why, and what is the fix? They share one variable, which had reached its final value before they ran. Give each thread a pointer to its own data.

1. Why does the total in ten.c never change while the order of the lines does? Each thread

wrote to its own structure, so nothing was shared and no result depended on the order. Only the moment each thread reached the screen depended on the scheduler.