Kemahiran pengaturcaraan berbilang benang dalam C++

Dengan peningkatan berterusan perkakasan komputer, semakin banyak perisian mula menggunakan teknologi multi-threading untuk meningkatkan prestasi program dan kelajuan tindak balas. Bahasa C++ ialah bahasa yang menyokong pengaturcaraan berbilang benang Artikel ini akan memperkenalkan beberapa teknik pengaturcaraan berbilang benang dalam C++.

1. Fahami konsep multi-threading

Sebelum melakukan pengaturcaraan multi-thread, kita perlu faham apa itu thread. Benang ialah unit terkecil pelaksanaan program Ia mempunyai pembilang program sendiri, set daftar dan tindanan, dan berkongsi segmen kod, segmen data dan sumber proses. Pengaturcaraan berbilang benang membolehkan kami melaksanakan berbilang utas pada masa yang sama, dan utas ini boleh melaksanakan secara serentak.

2. Gunakan kunci mutex untuk melindungi sumber yang dikongsi

Dalam pengaturcaraan berbilang benang, berbilang benang boleh mengakses sumber kongsi yang sama pada masa yang sama. Ini boleh membawa kepada ketidakkonsistenan data, jadi kita perlu menggunakan mutex untuk melindungi sumber yang dikongsi. Mutex ialah primitif penyegerakan yang membenarkan berbilang utas berkongsi sumber yang sama, tetapi hanya satu utas boleh mengakses sumber tersebut. Pustaka standard C++ menyediakan kelas std::mutex untuk menyokong mekanisme kunci mutex.

Sebagai contoh, kita boleh menggunakan coretan kod berikut untuk melindungi operasi baca dan tulis pembolehubah:

#include <mutex>
#include <iostream>

std::mutex mtx; // 申明一个互斥锁

int main()
{
    int count = 0;
    std::thread t1([&count]() {
        for (int i = 0; i < 1000000; i++) {
            mtx.lock(); // 加锁
            count++;
            mtx.unlock(); // 解锁
        }
    });

    std::thread t2([&count]() {
        for (int i = 0; i < 1000000; i++) {
            mtx.lock(); // 加锁
            count++;
            mtx.unlock(); // 解锁
        }
    });

    t1.join();
    t2.join();

    std::cout << "count: " << count << std::endl;
    return 0;
}

Dalam kod di atas, kami melindungi operasi baca dan tulis pembolehubah kiraan dengan mencipta objek std::mutex mtx. Gunakan fungsi mtx.lock() untuk mengunci objek mtx dan menghalang benang lain daripada mengakses pembolehubah kiraan. Menggunakan fungsi mtx.unlock() boleh membuka kunci objek mtx dan membenarkan urutan lain mengakses pembolehubah kiraan.

3. Gunakan pembolehubah keadaan untuk menunggu dan memberitahu urutan

Dalam pengaturcaraan berbilang benang, kadangkala kita perlu menunggu syarat tertentu dipenuhi sebelum meneruskan pelaksanaan. Dalam kes ini, anda boleh menggunakan pembolehubah keadaan untuk menunggu dan memberitahu urutan lain.

Pembolehubah keadaan ialah mekanisme penyegerakan yang membenarkan urutan menunggu acara tertentu dan bukannya sibuk menunggu. Apabila benang menunggu pembolehubah keadaan, ia akan tidur sehingga utas lain memberitahunya melalui pembolehubah keadaan. Pustaka standard C++ menyediakan kelas std::condition_variable untuk menyokong mekanisme pembolehubah keadaan.

Sebagai contoh, kami boleh menggunakan coretan kod berikut untuk menunggu dan memberitahu urutan:

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

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

void work()
{
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return is_ready; }); // 等待条件变量满足
    std::cout << "Work started!" << std::endl;
}

int main()
{
    std::thread t(work);

    std::this_thread::sleep_for(std::chrono::seconds(2));

    {
        std::lock_guard<std::mutex> lock(mtx);
        is_ready = true;
    }

    cv.notify_one(); // 通知工作线程条件变量
    t.join();
    return 0;
}

Dalam kod di atas, kami mencipta benang pekerja t dan menggunakan std::unique_lock Thread t menunggu pembolehubah keadaan dipenuhi sebelum meneruskan pelaksanaan. Dalam urutan utama, kami menggunakan std::lock_guard untuk mengunci mutex dan menukar nilai pembolehubah is_ready, dan kemudian memberitahu utas bahawa pembolehubah keadaan t telah dipenuhi melalui cv.notify_one().

4. Gunakan std::atomic untuk memastikan operasi atom

Dalam pengaturcaraan berbilang benang, berbilang benang biasanya mengubah suai pembolehubah yang sama pada masa yang sama. Dalam kes ini, kita perlu memastikan bahawa operasi pada pembolehubah adalah atom. Pustaka standard C++ menyediakan jenis std::atomic untuk menyokong operasi atom.

std::jenis atom boleh menjamin bahawa operasi adalah atom, iaitu, ia memastikan bahawa satu set operasi tidak akan diganggu oleh benang lain dalam apa jua keadaan. Gunakan kelas std::atomic untuk mengelakkan keadaan perlumbaan dan masalah lain yang berkaitan dengan pelbagai benang.

Sebagai contoh, kita boleh menggunakan coretan kod berikut untuk menunjukkan penggunaan std::atomic:

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

std::atomic<int> counter(0); // 申明一个原子性变量

void func()
{
    for (int i = 0; i < 1000000; ++i) {
        counter++; // 自增操作
    }
}

int main()
{
    std::thread t1(func);
    std::thread t2(func);

    t1.join();
    t2.join();

    std::cout << "counter: " << counter << std::endl;
    return 0;
}

Dalam kod di atas, kita mencipta dua utas t1 dan t2, dan menggunakan pembilang jenis std::atomic

Ringkasan

Artikel ini memperkenalkan beberapa teknik pengaturcaraan berbilang benang dalam C++. Menggunakan mutexes dan pembolehubah keadaan boleh melindungi sumber yang dikongsi dan melaksanakan komunikasi benang, sambil menggunakan std::atomic boleh menjamin operasi atom dan mengelakkan masalah berkaitan berbilang benang. Apabila menggunakan pengaturcaraan berbilang benang, sila beri perhatian kepada keselamatan dan ketepatan benang, dan pastikan bahawa operasi pada sumber yang dikongsi adalah atom.

Atas ialah kandungan terperinci Kemahiran pengaturcaraan berbilang benang dalam C++. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!