C Multithreading and Concurrency: Mastering Parallel Programming

C The core concepts of multithreading and concurrent programming include thread creation and management, synchronization and mutual exclusion, conditional variables, thread pooling, asynchronous programming, common errors and debugging techniques, and performance optimization and best practices. 1) Create threads using the std::thread class. The example shows how to create and wait for the thread to complete. 2) Synchronize and mutual exclusion to use std::mutex and std::lock_guard to protect shared resources and avoid data competition. 3) Condition variables realize communication and synchronization between threads through std::condition_variable. 4) The thread pool example shows how to use the ThreadPool class to process tasks in parallel to improve efficiency. 5) Asynchronous programming is implemented using std::async and std::future. The example shows the startup and result acquisition of asynchronous tasks. 6) Common errors include data competition, deadlocks and resource leakage, debugging skills include using locks and atomic operations, and debugging tools. 7) Performance optimization suggestions include the use of thread pools, std::atomic and reasonable use of locks to improve program performance and security.

introduction

In modern programming, multithreading and concurrent programming have become a key technology to improve program performance and responsiveness. Whether you are developing high-performance computing applications or building a responsive user interface, mastering multi-threading and concurrent programming in C is an essential skill. This article will take you into the deep understanding of the core concepts and practical techniques of C multithreading and concurrent programming, helping you become a master of parallel programming.

By reading this article, you will learn how to create and manage threads, understand synchronization and mutual exclusion mechanisms in concurrent programming, and how to avoid common concurrent programming pitfalls. Whether you are a beginner or an experienced developer, you can benefit from it.

Review of basic knowledge

Before diving into C multithreading and concurrent programming, let's review some basics first. The C 11 standard introduces the <thread></thread> library, making creating and managing threads in C easier and more intuitive. In addition, libraries such as <mutex></mutex> , <condition_variable></condition_variable> and <atomic></atomic> provide the necessary tools to handle synchronization and communication between threads.

Understanding these basic concepts is crucial to mastering multi-threaded programming. For example, threads are the smallest unit of operating system scheduling, while mutexes are used to protect shared resources and prevent data competition.

Core concept or function analysis

Thread creation and management

In C, creating a thread is very simple, just use std::thread class. Here is a simple example:

 #include <iostream>
#include <thread>

void thread_function() {
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    std::thread t(thread_function);
    t.join();
    return 0;
}

This example shows how to create a thread and wait for it to complete. join() method blocks the main thread until the child thread completes execution.

Synchronization and mutual exclusion

In multithreaded programming, synchronization and mutual exclusion are the key to avoiding data competition. std::mutex and std::lock_guard are commonly used tools. Here is an example of using mutex to protect shared resources:

 #include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;
int shared_data = 0;

void increment() {
    for (int i = 0; i < 100000; i) {
        std::lock_guard<std::mutex> lock(mtx);
          shared_data;
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "Final value of shared_data: " << shared_data << std::endl;
    return 0;
}

In this example, std::lock_guard ensures that the mutex is properly locked and unlocked when accessing shared_data , avoiding data competition.

Conditional variables

Condition variables are another important synchronization mechanism used for communication between threads. Here is an example of using conditional variables:

 #include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void print_id(int id) {
    std::unique_lock<std::mutex> lck(mtx);
    while (!ready) cv.wait(lck);
    std::cout << "Thread " << id << std::endl;
}

void go() {
    std::unique_lock<std::mutex> lck(mtx);
    ready = true;
    cv.notify_all();
}

int main() {
    std::thread threads[10];
    for (int i = 0; i < 10; i) {
        threads[i] = std::thread(print_id, i);
    }
    std::cout << "10 threads ready to race..." << std::endl;
    go();
    for (auto& th : threads) th.join();
    return 0;
}

In this example, the condition variable cv is used to notify all waiting threads to start execution.

Example of usage

Basic usage

Creating and managing threads is the basis of multi-threaded programming. Here is a more complex example showing how to use thread pools to process tasks in parallel:

 #include <iostream>
#include <vector>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>

class ThreadPool {
public:
    ThreadPool(size_t threads) : stop(false) {
        for (size_t i = 0; i < threads; i) {
            workers.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(queue_mutex);
                        condition.wait(lock, [this] { return stop || !tasks.empty(); });
                        if (stop && tasks.empty()) return;
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args) 
        -> std::future<typename std::result_of<F(Args...)>::type>
    {
        using return_type = typename std::result_of<F(Args...)>::type;

        auto task = std::make_shared<std::packaged_task<return_type()>>(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );

        std::future<return_type> res = task->get_future();
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            if (stop) throw std::runtime_error("enqueue on stopped ThreadPool");
            tasks.emplace([task]() { (*task)(); });
        }
        condition.notify_one();
        return res;
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread &worker : workers) worker.join();
    }

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;

    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};

int main() {
    ThreadPool pool(4);
    std::vector<std::future<int>> results;

    for (int i = 0; i < 8; i) {
        results.emplace_back(
            pool.enqueue([i] {
                return i * i;
            })
        );
    }

    for (auto && result : results) {
        std::cout << result.get() << &#39; &#39;;
    }
    std::cout << std::endl;

    return 0;
}

This example shows how to use thread pools to process tasks in parallel, improving program concurrency and efficiency.

Advanced Usage

In practical applications, more complex concurrent programming scenarios may be encountered. For example, use std::async and std::future to implement asynchronous programming:

 #include <iostream>
#include <future>
#include <chrono>

int main() {
    auto future = std::async(std::launch::async, [] {
        std::this_thread::sleep_for(std::chrono::seconds(2));
        return 42;
    });

    std::cout << "Waiting for result..." << std::endl;
    int result = future.get();
    std::cout << "Result: " << result << std::endl;

    return 0;
}

In this example, std::async is used to start an asynchronous task, std::future is used to get the results of the task.

Common Errors and Debugging Tips

Common errors in multithreaded programming include data race, deadlocks, and resource leakage. Here are some debugging tips:

• Use std::lock_guard and std::unique_lock to ensure the correct use of mutexes and avoid deadlocks.
• Use std::atomic to handle shared variables and avoid data competition.
• Use debugging tools such as Valgrind or AddressSanitizer to detect memory leaks and data competition.

Performance optimization and best practices

In practical applications, it is crucial to optimize the performance of multi-threaded programs. Here are some optimization tips and best practices:

• Avoid excessive thread creation and destruction and use thread pools to manage threads.
• Use std::atomic to improve access efficiency of shared variables.
• Use locks reasonably to reduce the granularity of locks and avoid lock competition.

For example, here is an example of using std::atomic to optimize access to shared variables:

 #include <iostream>
#include <thread>
#include <atomic>

std::atomic<int> shared_data(0);

void increment() {
    for (int i = 0; i < 100000; i) {
          shared_data;
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "Final value of shared_data: " << shared_data << std::endl;
    return 0;
}

In this example, using std::atomic to ensure atomic operations of shared variables improves program performance and security.

In short, C multithreading and concurrent programming is a complex but very useful technique. Through the study of this article, you should have mastered the core concepts and techniques such as creating and managing threads, synchronization and mutual exclusion, and performance optimization. I hope this knowledge can help you better apply multi-threaded programming in real projects and improve program performance and responsiveness.

The above is the detailed content of C Multithreading and Concurrency: Mastering Parallel Programming. For more information, please follow other related articles on the PHP Chinese website!