Bagaimana untuk menggunakan multithreading dengan cekap dalam C++?

Menggunakan multithreading dalam C++ boleh meningkatkan keselarian: Cipta benang: Gunakan kelas std::thread atau pustaka pthread untuk mencipta benang. Segerakkan benang: Gunakan mekanisme penyegerakan seperti mutex dan pembolehubah keadaan untuk memastikan keselamatan benang. Kes praktikal: Contohnya, jika berbilang fail diproses secara selari, berbilang benang dicipta untuk memproses setiap fail untuk meningkatkan kecekapan.

Menggunakan Multithreading dengan Cekap dalam C++

Pengaturcaraan berbilang benang adalah penting dalam pembangunan perisian kerana ia meningkatkan keselarian dan prestasi aplikasi. Artikel ini akan memperkenalkan cara menggunakan ciri berbilang benang dalam C++ dengan berkesan, termasuk penciptaan benang, penyegerakan dan kes praktikal. . Gunakan pembina std::thread, lulus fungsi thread dan sebarang parameter.

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

perpustakaan pthread:
Pilihan lain ialah menggunakan perpustakaan POSIX thread (pthread). Sertakan fail pengepala pthread.h dan gunakan fungsi pthread_create untuk mencipta urutan.

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

Salin selepas log masuk
1. Penyegerakan benangstd::thread 构造函数，传递线程函数和任意参数。

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

Salin selepas log masuk
2. pthread 库：另一种选择是使用 POSIX 线程 (pthread) 库。包括 pthread.h 头文件并使用 pthread_create 函数创建线程。

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

Salin selepas log masuk

线程同步

为了确保多个线程在访问共享数据时不会相互干扰，需要进行线程同步。C++ 提供了几种同步方法：

1. 互斥量：std::mutex 类控制对共享数据的独占访问。只允许一个线程同时持有互斥锁。

#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;
}

Salin selepas log masuk
2. 条件变量：std::condition_variableUntuk memastikan berbilang benang tidak mengganggu satu sama lain semasa mengakses data kongsi, penyegerakan benang diperlukan. C++ menyediakan beberapa kaedah penyegerakan:

Mutex: Kelas std::mutex mengawal akses eksklusif kepada data kongsi. Hanya satu benang dibenarkan untuk memegang kunci mutex pada masa yang sama.

rrreee

Pembolehubah keadaan: Kelas

std::condition_variable digunakan untuk memberitahu urutan tentang perubahan dalam keadaan. Benang boleh menunggu syarat dipenuhi sebelum meneruskan pelaksanaan. 🎜🎜rrreee🎜🎜Kes Praktikal: Pemprosesan Fail Serentak🎜🎜🎜Untuk menggambarkan penggunaan multi-threading, mari kita pertimbangkan program yang memproses berbilang fail secara selari. Program harus membaca setiap baris fail dan menulisnya ke fail output. 🎜rrreee🎜Dalam contoh ini, kami mencipta beberapa utas, setiap utas memproses satu fail. Benang utama mencipta fail output dan menunggu semua utas selesai. Dengan cara ini kita boleh memproses berbilang fail secara selari, sekali gus meningkatkan prestasi. 🎜

Atas ialah kandungan terperinci Bagaimana untuk menggunakan multithreading dengan cekap dalam C++?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!