#include <pthread.h>

int pthread_create(pthread_t        *thread,
                   const pthread_attr_t *attr,
                   void *(*start)(void *),
                   void             *arg);

/* Returns: 0 on success, positive error number on failure */

This function has four parameters. Let’s understand each one carefully:

Every thread you create must have a start function with exactly this signature:

void *my_thread_function(void *arg);

Rules for the start function:

• Takes void *: You can pass any type of data as arg — a primitive cast to pointer, or a pointer to a struct. Cast it back inside the function.
• Returns void *: This return value can be retrieved by another thread calling pthread_join(). You can return status codes, pointers to results, etc.
• Stack safety: Do NOT return a pointer to a local variable — the stack frame is destroyed when the function returns and the thread terminates. Return heap-allocated data or a global, or a simple integer cast.
• Avoid PTHREAD_CANCELED: That special cancellation value is usually an integer cast to void *. If your thread returns the same integer value, a joining thread may confuse it for cancellation.

The arg parameter is a single void *. You can use it in three common ways:

pthread_create(&tid, NULL, fn,
  (void *)(intptr_t) 42);

int val = 5;
pthread_create(&tid, NULL, fn, &val);

struct Args { int x; char *s; };
struct Args *a = malloc(sizeof *a);
pthread_create(&tid,NULL,fn,a);

This is the classic “Hello World” equivalent for threads — the program from TLPI Listing 29-1.

/* compile: gcc -pthread -o simple_thread simple_thread.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

/* ---- start function for the new thread ---- */
static void *threadFunc(void *arg)
{
    char *s = (char *) arg;   /* cast void* back to char* */
    printf("%s", s);

    /* Return length of string as exit value (cast int → void*) */
    return (void *)(intptr_t) strlen(s);
}

int main(void)
{
    pthread_t t1;
    void      *res;   /* will hold thread's return value */
    int        s;

    /* Create thread — pass string as argument */
    s = pthread_create(&t1, NULL, threadFunc, "Hello world\n");
    if (s != 0) {
        fprintf(stderr, "pthread_create: %s\n", strerror(s));
        exit(EXIT_FAILURE);
    }

    printf("Message from main()\n");

    /* Wait for thread to finish and retrieve its return value */
    s = pthread_join(t1, &res);
    if (s != 0) {
        fprintf(stderr, "pthread_join: %s\n", strerror(s));
        exit(EXIT_FAILURE);
    }

    printf("Thread returned %ld\n", (long)(intptr_t) res);
    exit(EXIT_SUCCESS);
}

Sample output (order of first two lines may vary):

Message from main()
Hello world
Thread returned 12

The output order can vary because after pthread_create() returns, both the main thread and the new thread are runnable. The scheduler decides which prints first.

When you need to pass more than one value to a thread, the cleanest approach is to allocate a struct on the heap and pass its address as arg.

/* compile: gcc -pthread -o thread_struct thread_struct.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

/* Struct to hold multiple arguments */
struct ThreadArgs {
    int   thread_num;
    char  message[64];
};

static void *worker(void *arg)
{
    struct ThreadArgs *targs = (struct ThreadArgs *) arg;

    printf("Thread %d says: %s\n", targs->thread_num, targs->message);

    free(targs);   /* free heap allocation (thread owns it now) */
    return NULL;
}

int main(void)
{
    pthread_t tid[3];
    int s;

    for (int i = 0; i < 3; i++) {
        struct ThreadArgs *a = malloc(sizeof(struct ThreadArgs));
        if (!a) { perror("malloc"); exit(1); }

        a->thread_num = i + 1;
        snprintf(a->message, sizeof(a->message),
                 "Hello from worker %d!", i + 1);

        s = pthread_create(&tid[i], NULL, worker, a);
        if (s != 0) {
            fprintf(stderr, "pthread_create: %s\n", strerror(s));
            exit(EXIT_FAILURE);
        }
    }

    /* Wait for all three threads */
    for (int i = 0; i < 3; i++)
        pthread_join(tid[i], NULL);

    printf("All threads done.\n");
    return 0;
}

Important: We allocate each thread’s argument struct with malloc() so every thread gets its own independent copy. If we used a single stack variable in a loop, all threads would read the same (possibly already-changed) memory. The thread itself calls free() after reading its arguments.