Penerokaan teori dan praktikal pengaturcaraan serentak C++

C++ pengaturcaraan serentak melaksanakan pelaksanaan serentak berbilang tugas melalui mekanisme seperti benang, mutex, pembolehubah keadaan dan operasi atom. Dalam kes praktikal, program pemprosesan imej berbilang benang membahagikan imej kepada blok dan memproses blok ini secara selari melalui kumpulan benang, memendekkan masa pemprosesan.

Meneroka teori dan amalan pengaturcaraan serentak dalam C++

Pengenalan
Pengaturcaraan serentak melibatkan melaksanakan pelbagai tugas pada masa yang sama, dan ia telah menjadi bahagian yang amat diperlukan dalam pembangunan perisian moden. Bahasa C++ menyediakan banyak ciri konkurensi, dan artikel ini akan menyelidiki asas teori dan aplikasi praktikal ciri ini.

Asas teori

• Thread: Unit pelaksanaan ringan yang berkongsi sumber proses, seperti memori dan deskriptor fail.
• Mutex: Primitif penyegerakan yang digunakan untuk melindungi kawasan kritikal dan memastikan hanya satu utas boleh mengakses kawasan ini pada masa yang sama.
• Pembolehubah Keadaan: Satu lagi primitif penyegerakan yang membolehkan benang menunggu untuk syarat tertentu dipenuhi.
• Operasi atom: Operasi pada data yang dikongsi memastikan bahawa operasi tidak terganggu, sekali gus memastikan integriti data.

Kes Amalan: Pemprosesan Imej Berbilang Benang
Untuk menunjukkan aplikasi praktikal pengaturcaraan serentak, kami akan melaksanakan program pemprosesan imej berbilang benang yang membahagikan imej kepada berbilang blok dan melaksanakan pemprosesan imej secara selari pada setiap blok Tugasan .

Pelaksanaan kod

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

using namespace std;

// 图像块结构体
struct ImageBlock {
    int start_row;  // 块的起始行
    int start_col;  // 块的起始列
    int width;      // 块的宽度
    int height;     // 块的高度
};

// 共享变量保护
mutex m;
condition_variable cv;

// 是否已处理完所有块
bool done = false;

// 图片处理函数
void processImageBlock(ImageBlock block) {
    // ... 实际的图像处理操作 ...
}

// 线程处理函数
void threadFunc(vector<ImageBlock>& blocks) {
    while (!done) {
        // 获取一个未处理的块
        unique_lock<mutex> lk(m);
        ImageBlock block;
        for (auto& b : blocks) {
            if (!b.processed) {
                block = b;
                b.processed = true;
                break;
            }
        }
        // 如果没有未处理的块，则等待
        if (!block.processed) {
            cv.wait(lk);
        }
        // 对块进行处理
        processImageBlock(block);
    }
}

int main() {
    // 划分图像为块
    vector<ImageBlock> blocks;
    // ... 省略分割图像的代码 ...

    // 创建线程池
    vector<thread> threads;
    for (int i = 0; i < 4; i++) {
        threads.emplace_back(threadFunc, ref(blocks));
    }

    // 等待所有线程完成
    {
        unique_lock<mutex> lk(m);
        done = true;
        cv.notify_all();
    }
    for (auto& t : threads) {
        t.join();
    }

    return 0;
}

Hasil berjalan
Program ini akan memproses blok dalam imej secara selari, sekali gus memendekkan masa pemprosesan keseluruhan. Output akan menunjukkan butiran blok yang diproses oleh setiap utas.

Ringkasan
Artikel ini meneroka asas teori dan aplikasi praktikal pengaturcaraan serentak C++. Dengan memperkenalkan konsep seperti mutex, pembolehubah keadaan dan operasi atom, kami menunjukkan cara melaksanakan program berbilang benang yang selamat dan cekap. Kes praktikal menunjukkan aplikasi praktikal pengaturcaraan serentak dalam bidang pemprosesan imej.

Atas ialah kandungan terperinci Penerokaan teori dan praktikal pengaturcaraan serentak C++. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!