Bagaimana untuk melaksanakan pengaturcaraan serentak dalam kod C++?

Bagaimana untuk melaksanakan pengaturcaraan serentak dalam kod C++?

Dengan perkembangan teknologi komputer, aplikasi pemproses berbilang teras dan pengkomputeran selari menjadi semakin biasa. Bagi pembangun program, cara menggunakan keupayaan pengkomputeran selari pemproses berbilang teras untuk meningkatkan prestasi program telah menjadi topik penting. Sebagai bahasa pengaturcaraan yang berkuasa, C++ menyediakan pelbagai alatan dan perpustakaan untuk pengaturcaraan serentak. Artikel ini akan memperkenalkan cara melaksanakan pengaturcaraan serentak dalam kod C++.

1. Benang dan proses

Dalam C++, benang dan proses boleh digunakan untuk melaksanakan pengaturcaraan serentak. Benang ialah unit pelaksanaan program, dan berbilang benang boleh dilaksanakan secara selari, manakala proses ialah contoh program, dan proses berbeza boleh dilaksanakan secara selari. Pengkomputeran selari boleh dicapai dengan mencipta berbilang benang atau proses.

C++ menyediakan sokongan berbilang benang, dan anda boleh menggunakan kelas std::thread untuk mencipta dan mengurus benang. Berikut ialah contoh mudah:

#include <iostream>
#include <thread>

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

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

Dalam contoh ini, kami mencipta utas bernama t dan kemudian memanggil fungsi join()nya untuk menunggu urutan menyelesaikan pelaksanaan. Dalam contoh ini, fungsi utas hello() mengeluarkan mesej.

2. Mutex lock

Dalam pengaturcaraan serentak, apabila berbilang rangkaian mengakses sumber dikongsi pada masa yang sama, ia mungkin membawa kepada persaingan data dan tingkah laku yang tidak menentu. Untuk mengelakkan situasi ini, anda boleh menggunakan mutex untuk melindungi sumber yang dikongsi. C++ menyediakan kelas std::mutex untuk melaksanakan kunci mutex.

Berikut ialah contoh penggunaan mutex:

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

std::mutex mtx;

void count() {
    std::lock_guard<std::mutex> lock(mtx);
    for (int i = 0; i < 10; ++i) {
        std::cout << i << std::endl;
    }
}

int main() {
    std::thread t1(count);
    std::thread t2(count);
    t1.join();
    t2.join();
    return 0;
}

Dalam contoh ini, kami mencipta dua utas t1 dan t2, yang mengakses pembilang gelung pada masa yang sama. Untuk memastikan keselamatan akses serentak, kami menggunakan kunci mutex mtx. Kelas std::lock_guard ialah kelas RAII (pemerolehan sumber iaitu permulaan) yang digunakan untuk melepaskan kunci secara automatik.

3. Pembolehubah keadaan

Dalam pengaturcaraan serentak, komunikasi dan penyegerakan antara utas kadangkala diperlukan. C++ menyediakan pembolehubah keadaan (condition_variable) untuk melaksanakan urutan menunggu dan bangun.

Berikut ialah contoh penggunaan pembolehubah keadaan:

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

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

void worker() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return ready; });
    std::cout << "Worker thread is running!" << std::endl;
}

int main() {
    std::thread t(worker);
    std::this_thread::sleep_for(std::chrono::seconds(2));
    
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_one();
    
    t.join();
    return 0;
}

Dalam contoh ini, kami mencipta benang t yang menunggu nilai pembolehubah sedia menjadi benar. Dalam utas utama, kami menunggu selama 2 saat, tetapkan sedia kepada benar, dan memberitahu utas t melalui fungsi notify_one() pembolehubah keadaan cv.

4. Bekas serentak

C++ menyediakan beberapa kelas kontena serentak, seperti std::list, std::queue, std::map, dsb., yang digunakan untuk mengakses dan mengubah suai elemen dengan selamat dalam berbilang rangkaian .

Berikut ialah contoh penggunaan baris gilir serentak std::gilir:

#include <iostream>
#include <thread>
#include <queue>

std::queue<int> q;
std::mutex mtx;

void producer() {
    for (int i = 0; i < 10; ++i) {
        std::lock_guard<std::mutex> lock(mtx);
        q.push(i);
    }
}

void consumer() {
    while (true) {
        std::lock_guard<std::mutex> lock(mtx);
        if (!q.empty()) {
            int value = q.front();
            q.pop();
            std::cout << "Consumed: " << value << std::endl;
        }
        else {
            break;
        }
    }
}

int main() {
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join();
    t2.join();
    return 0;
}

Dalam contoh ini, kami mencipta urutan pengeluar dan urutan pengguna. Benang pengeluar menambah elemen pada baris gilir dan urutan pengguna mengambil elemen daripada baris gilir untuk penggunaan. Untuk memastikan keselamatan akses serentak, kami menggunakan mutex mtx.

Ringkasan:

Melalui pengaturcaraan urutan dan proses serentak, anda boleh menggunakan sepenuhnya keupayaan pengkomputeran selari pemproses berbilang teras dan meningkatkan prestasi program. C++ menyediakan pelbagai alatan dan perpustakaan, seperti std::thread, std::mutex, std::condition_variable dan bekas serentak, untuk melaksanakan pengaturcaraan serentak. Apabila melakukan pengaturcaraan serentak, anda perlu memberi perhatian kepada persaingan data dan isu penyegerakan untuk mengelakkan berlakunya tingkah laku yang tidak menentu. Dalam aplikasi praktikal, memilih penyelesaian pengaturcaraan serentak yang sesuai berdasarkan keperluan khusus boleh meningkatkan lagi prestasi program.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan pengaturcaraan serentak dalam kod C++?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!