How to use multithreading efficiently in C++?

Using multithreading in C++ can improve parallelism: Create threads: Use the std::thread class or the pthread library to create threads. Synchronize threads: Use synchronization mechanisms such as mutexes and condition variables to ensure thread safety. Practical case: For example, if multiple files are processed in parallel, multiple threads are created to process each file to improve efficiency.

Using Multithreading Efficiently in C++

Multi-threaded programming is crucial in software development as it improves Parallelism and application performance. This article will introduce how to effectively use multi-threading features in C++, including thread creation, synchronization and practical cases.

Thread creation

There are two ways to create a thread in C++:

1. std::thread class:# Introduced in ##C++11, providing a modern way to create and manage threads. Use the std::thread constructor, passing the thread function and any parameters.

std::thread t(my_function, arg1, arg2);

2. pthread library: Another option is to use the POSIX threads (pthread) library. Include the pthread.h header file and use the pthread_create function to create the thread.

pthread_t t;
pthread_create(&t, NULL, my_function, arg1);

Thread synchronization

In order to ensure that multiple threads do not interfere with each other when accessing shared data, thread synchronization is required. C++ provides several synchronization methods:

1. Mutex: The std::mutex class controls exclusive access to shared data. Only one thread is allowed to hold the mutex lock at the same time.

std::mutex m;
{
    std::lock_guard<std::mutex> lock(m);
    // 对共享数据进行操作
}

2. Condition variable: std::condition_variable class is used to notify threads about changes in conditions. The thread can wait for the condition to be met before continuing execution.

std::condition_variable cv;
std::mutex m;
{
    std::unique_lock<std::mutex> lock(m);
    // 等待条件达成
    cv.wait(lock);
}

Practical Case: Concurrent File Processing

To illustrate the use of multi-threading, let us consider a program that processes multiple files in parallel. The program should read each line of the file and write it to the output file.

#include <iostream>
#include <fstream>
#include <vector>
#include <thread>

using namespace std;

void process_file(string filename, ofstream& out)
{
    ifstream in(filename);
    string line;
    while (getline(in, line))
    {
        out << line << endl;
    }
}

int main()
{
    // 文件名列表
    vector<string> filenames = {"file1.txt", "file2.txt", "file3.txt"};

    // 创建 output 输出文件
    ofstream out("output.txt");

    // 创建线程向量
    vector<thread> threads;

    // 为每个文件创建线程
    for (auto& filename : filenames)
    {
        threads.emplace_back(process_file, filename, ref(out));
    }

    // 等待线程完成
    for (auto& thread : threads)
    {
        thread.join();
    }

    cout << "Files processed successfully." << endl;
    return 0;
}

In this example, we create multiple threads, each thread processes one file. The main thread creates an output file and waits for all threads to complete. This way we can process multiple files in parallel, thus improving performance.

The above is the detailed content of How to use multithreading efficiently in C++?. For more information, please follow other related articles on the PHP Chinese website!