Why Do We Need Thread Cancellation?

Threads normally run until they finish their work and call pthread_exit() or return from their start function. But in real applications, you often need to stop a thread early — from outside that thread.

Consider these scenarios:

POSIX Threads provides pthread_cancel() for exactly this purpose.

The pthread_cancel() Function

Parameter Breakdown

Key Behaviors — What Happens When You Call It?

Code Example 1: Basic pthread_cancel() Usage

A thread runs an infinite loop. The main thread sends a cancellation request after 3 seconds, then joins to confirm it terminated.

/* basic_cancel.c - Demonstrates pthread_cancel() */
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

/* Thread function: runs an infinite loop, sleeping 1 sec each iteration */
static void *
workerThread(void *arg)
{
    int count = 0;

    printf("Worker: started\n");

    while (1) {
        count++;
        printf("Worker: loop iteration %d\n", count);
        sleep(1);    /* sleep() is a cancellation point */
    }

    /* Never reached normally */
    return NULL;
}

int
main(void)
{
    pthread_t tid;
    void *retval;
    int s;

    /* Create the worker thread */
    s = pthread_create(&tid, NULL, workerThread, NULL);
    if (s != 0) {
        perror("pthread_create");
        exit(EXIT_FAILURE);
    }

    sleep(3);    /* Let worker run for 3 seconds */

    printf("Main: sending cancellation request\n");

    /* Send cancellation request — does NOT block */
    s = pthread_cancel(tid);
    if (s != 0) {
        perror("pthread_cancel");
        exit(EXIT_FAILURE);
    }

    printf("Main: cancel sent, now joining...\n");

    /* Join to wait for thread termination and reclaim resources */
    s = pthread_join(tid, &retval);
    if (s != 0) {
        perror("pthread_join");
        exit(EXIT_FAILURE);
    }

    /* Check if thread was canceled or ended normally */
    if (retval == PTHREAD_CANCELED)
        printf("Main: thread was canceled (confirmed)\n");
    else
        printf("Main: thread ended normally\n");

    return 0;
}

Code Example 2: Canceling One Thread from Another Worker

Two worker threads run in parallel. Worker-2 detects a problem and cancels Worker-1 before the main thread joins both.

/* worker_cancel.c - One thread cancels another */
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

/* Shared thread ID so worker2 can cancel worker1 */
static pthread_t worker1_tid;

static void *
worker1(void *arg)
{
    printf("Worker1: running, tid=%lu\n", (unsigned long)pthread_self());
    while (1) {
        printf("Worker1: doing work...\n");
        sleep(1);
    }
    return NULL;
}

static void *
worker2(void *arg)
{
    printf("Worker2: running, will cancel Worker1 after 2s\n");
    sleep(2);

    /* Simulate: worker2 detects an error, cancels worker1 */
    printf("Worker2: ERROR detected! Canceling Worker1\n");
    int s = pthread_cancel(worker1_tid);
    if (s != 0) {
        perror("pthread_cancel from worker2");
    }

    printf("Worker2: cancel request sent, exiting\n");
    return (void *)42;   /* Worker2 ends normally */
}

int
main(void)
{
    pthread_t w2_tid;
    void *res1, *res2;

    pthread_create(&worker1_tid, NULL, worker1, NULL);
    pthread_create(&w2_tid,      NULL, worker2, NULL);

    pthread_join(worker1_tid, &res1);
    pthread_join(w2_tid,      &res2);

    printf("Main: Worker1 status = %s\n",
           (res1 == PTHREAD_CANCELED) ? "CANCELED" : "NORMAL");
    printf("Main: Worker2 exit value = %ld\n", (long)res2);

    return 0;
}

Interview Questions — Section 32.1