Revision as of 08:15, 19 April 2024

Using pthreads

Single thread example

The example below shows the syntax of pthreads. The thread doesn't do anything useful.

compile with: gcc pt1.c -o pt -pthread

 1 #include <stdio.h>
 2 #include <pthread.h>
 3 
 4 long counter;
 5 void * adder(void * data) {
 6         for (int i=0; i < 1000000; i++)
 7                 counter++;
 8 }
 9 
10 int main(void) {
11         int i;
12         pthread_t pt;
13 
14         counter=0;
15         pthread_create(&pt, NULL, adder, NULL);
16         pthread_join(pt, NULL);
17         printf("Value of counter is %ld\n", counter);
18         return(0);
19 }

When creating a pthread with pthread_create() resources are allocated in the running process for the thread. pthread_join() waits for the thread to finish and releases its resources.

Using multiple threads

Using multiple threads simultaneously can give race conditions as the code below shows when running.

 1 #include <stdio.h>
 2 #include <pthread.h>
 3 
 4 #define THREADS 2
 5 
 6 long counter;
 7 void * adder(void * data) {
 8         for (int i=0; i < 100000000; i++)
 9                 counter++;
10 }
11 
12 int main(void) {
13         int i;
14         pthread_t pt[THREADS];
15 
16         counter=0;
17 
18         for (i=0; i < THREADS; i++) {
19                 pthread_create(&pt[i], NULL, adder, NULL);
20                 printf("Created thread %d\n",i+1);
21         }
22 
23         for (i=0; i < THREADS; i++) {
24                 pthread_join(pt[i], NULL);
25                 printf("Joined thread %d\n",i+1);
26         }
27 
28         printf("Value of counter is %ld\n", counter);
29         return(0);
30 }

Running the code two times gave this output as example:

Note: The two wrong counter values.

heth@emb3:~/bin$ pt2
Created thread 1
Created thread 2
Joined thread 1
Joined thread 2
Value of counter is 1032119
heth@emb3:~/bin$ pt2
Created thread 1
Created thread 2
Joined thread 1
Joined thread 2
Value of counter is 1081391

Using mutexes

A Mutex or Mutual exclusion is a lock that can be owned by only thread at a time. When unlocked another thread can lock it.

#include <stdio.h>
#include <pthread.h>

#define THREADS 2

long counter;
pthread_mutex_t mutex;

void * adder(void * data) {
        for (int i=0; i < 1000000; i++) {
                pthread_mutex_lock(&mutex) ;
                counter++;
                pthread_mutex_unlock(&mutex);
        }
}

int main(void) {
        int i;
        pthread_t pt[THREADS];


        counter=0;
        if (pthread_mutex_init(&mutex, NULL) != 0)
                printf("Mutex init failed\n");

        for (i=0; i < THREADS; i++) {
                pthread_create(&pt[i], NULL, adder, NULL);
                printf("Created thread %d\n",i+1);
        }

        for (i=0; i < THREADS; i++) {
                pthread_join(pt[i], NULL);
                printf("Joined thread %d\n",i+1);
        }

        printf("Value of counter is %ld\n", counter);
        return(0);
}

The output from this example is accurate:

heth@emb3:~/bin$ pt1_mutex
Created thread 1
Created thread 2 
Joined thread 1
Joined thread 2
Value of counter is 2000000

Releasing resources used by a pthread

To release the resources - memory for stack and householding - it is necessary to call either pthread_detach or pthread_join. The resources are not released when the pthread exits without one of these calls.

pthread_join is called by the process or another thread.
pthread_detach is typically called by the thread itself to release the resources when the thread terminates

See threads of a running process

Using ps

To see the thread ids - TID - of a running process use ps -T or filter as below

heth@emb3:~/bin/process-and-thread/thread$ ps -L xo pid,ppid,tid,cmd | grep -P '(pt2|CMD)'
    PID     TID CMD
3516974 3516974 ./pt2_mutex
3516974 3516975 ./pt2_mutex
3516974 3516976 ./pt2_mutex
3522329 3522329 grep --color=auto -P (pt2|CMD)

NOTE: Some confusion about thread ID - TID and other abbreviations - in the man page for ps the value of TID can also appear as lwp or spid

Another example

The example below

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

// Compile with: gcc thread3.c -o thread3 -pthread -lc
//   Note: \x1b[ - are vt100 escape sequences. Google on it
//   Note: printf is reasonable treadsafe (see man  page)

void * thread_0(void * data) {

        static unsigned int count=0;
        char buf[100];

        while(count <  200) {
                count++;
                printf("\x1b[2;1HThread_0 count = %10d", count);
                fflush(stdout);
                usleep(100000);
        }
}

void * thread_1(void * data) {

        static unsigned int count=0;
        char buf[100];

        while(1) {
                count++;
                printf("\x1b[3;1HThread_1 count = %10d", count);
                fflush(stdout);
                pthread_testcancel();
                usleep(10000);
        }
}

void * thread_2(void * data) {

        static unsigned int count=0;
        char buf[100];

        while(1) {
                count++;
                printf("\x1b[4;1HThread_2 count = %10d", count);
                fflush(stdout);
                pthread_testcancel();
                usleep(1000000);
        }
}

int main(void) {
        int i;

        pthread_t pt[3];


        printf("\x1b[2J");
        fflush(stdout);
        pthread_create(&pt[0], NULL, thread_0, NULL);
        pthread_create(&pt[1], NULL, thread_1, NULL);
        pthread_create(&pt[2], NULL, thread_2, NULL);

        pthread_join(pt[0], NULL);
        printf("\x01b[8;1HJoined thread_0\n");
        usleep(3000000);

        pthread_cancel(pt[1]);
        printf("\x01b[9;1HCancelled  thread_1\n");
        usleep(3000000);

        pthread_cancel(pt[2]);
        printf("\x01b[10;1HCancelled  thread_2\n");
        usleep(3000000);

        printf("\x01b[11;1HExiting\n");

        return(0);
}

Run the following script in another terminal to see running threads

while :; do clear; ps -L xo pid,ppid,tid,cmd | grep -P '(thread3|CMD)'; sleep 0.5; done

Links

Navigation menu

Difference between revisions of "Pthread"