Multithreaded Programming in C: Using the pthread Library

In modern software development, multithreaded programming is an important method for handling concurrent tasks. Although C is a low-level language, it provides powerful tools for implementing multithreading, the most commonly used being the pthread (POSIX Threads) library. This article will detail how to use the pthread library for multithreaded programming in C, including basic concepts, code examples for creating and managing threads, and more.

1. What is pthread?

pthread is a set of APIs defined in the POSIX standard for creating and controlling threads. On UNIX and UNIX-like systems (such as Linux), pthread provides a standard way to create programs that execute concurrently. This means you can run multiple tasks simultaneously, thereby improving the execution efficiency of the program.

1.1 Basic Concepts

Thread: A lightweight process that shares the same memory space.
Main Thread: The linear execution path that is created by default when the program starts.
Child Thread: A new starting point created by the main thread or other child threads.

2. Basics of Using pthread

2.1 Including Header Files

To use the pthread library, you first need to include the header file:

#include <pthread.h>

2.2 Linking the pthread Library

When compiling, you need to link the pthread library, which can be done using the following command:

gcc -o my_program my_program.c -lpthread

3. Creating a Simple Multithreaded Example

Below, we will demonstrate how to use pthread to create and manage multiple threads through a simple example.

Example Code Explanation

This example program will start two child processes, each of which will print its ID along with a test message, and then exit.

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

void* thread_function(void* arg) {
    int thread_id = *(int*)arg;
    printf("Thread %d: Hello, World!\n", thread_id);
    sleep(1); // Simulate time-consuming operation
    printf("Thread %d: Goodbye!\n", thread_id);
    return NULL; // End this thread
}

int main() {
    pthread_t threads[2]; // Two threads
    int thread_args[2] = {0, 1}; // Arguments passed to the thread function

    for (int i = 0; i < 2; ++i) {
        if (pthread_create(&threads[i], NULL, thread_function, &thread_args[i])) {
            fprintf(stderr, "Error creating thread\n");
            return EXIT_FAILURE;
        }
    }

    for (int i = 0; i < 2; ++i) {
        pthread_join(threads[i], NULL); // Wait for each child thread to finish
    }

    printf("Main Thread: All threads completed.\n");
    return EXIT_SUCCESS;
}

Program Interpretation

Logic Flow in the Main Function:

Declare Variables:

Declare a pthread_t threads[2], used to store two child threads.
Declare an array thread_args, which stores the information passed to each thread function to indicate which independent thread they are, with index x decreasing to create a more organized model architecture.

Loop to Create New Threads:

Use a loop to call pthread_create() to create new threads. In this process, we set the required parameters and processing functions, using blocking operators as needed to implement more complex variable state requirements. (Note that the fourth item is a parameter passed from the previously defined value.)

Wait for Each New Thread to Complete and Resource Cleanup:

In the second loop, by calling the pthread_join() function, we prevent the main thread from proceeding until all child threads have completed execution. // Clear the current flow to avoid accidental interruptions and damage!

4. Finally, print “All threads completed.” to confirm the exit of the main content and output section.

Conclusion

Through the above content, we have briefly understood how to use the Pthread library to build a basic framework for multithreading in C. For more complex application scenarios, it may involve more intricate efficiency control and constraint design. In actual project development, you can also flexibly combine serial queue techniques to achieve more refined scheduling plans. At the same time, please ensure to release resources effectively to avoid system burden.