Konsep utama pengaturcaraan berbilang benang C++ ialah bagaimana untuk menyegerakkan benang?

Konsep kunci penyegerakan berbilang benang C++: Kunci Mutex: pastikan bahagian kritikal hanya boleh diakses oleh satu utas. Pembolehubah keadaan: Benang boleh dibangkitkan apabila syarat tertentu dipenuhi. Operasi atom: arahan CPU tunggal yang tidak terganggu untuk memastikan keatoman pengubahsuaian pembolehubah yang dikongsi.

Konsep utama pengaturcaraan berbilang benang C++: Penyegerakan utas

Penyegerakan utas ialah bahagian penting dalam pengaturcaraan berbilang utas Ia memastikan berbilang rangkaian boleh mengakses sumber dan data yang dikongsi dengan selamat. Berikut memperkenalkan konsep utama penyegerakan benang dalam C++:

Mutex:

Mutex (mutex) ialah mekanisme kawalan capaian yang membenarkan hanya satu utas mengakses bahagian kritikal pada satu masa, iaitu akses segerak diperlukan kawasan kod. Menggunakan kunci mutex boleh menghalang berbilang benang daripada mengubah suai pembolehubah yang dikongsi pada masa yang sama, menyebabkan kerosakan data.

std::mutex mtx;  // 定义互斥锁对象

void someFunction() {
    std::lock_guard<std::mutex> lock(mtx);  // 在进入临界区前加锁
    // 访问临界区代码
}

Pembolehubah bersyarat:

Pembolehubah bersyarat membenarkan benang dibangkitkan apabila syarat tertentu dipenuhi. Ini berguna dalam pengaturcaraan berbilang benang koperasi, seperti apabila satu utas sedang menunggu utas lain untuk menghasilkan data.

std::condition_variable cv;  // 定义条件变量对象
std::mutex mtx;  // 关联的互斥锁对象

void produce() {
    std::lock_guard<std::mutex> lock(mtx);  // 加锁
    // 产生数据
    cv.notify_all();  // 通知所有等待此条件的线程
}

void consume() {
    std::unique_lock<std::mutex> lock(mtx);  // 加锁
    cv.wait(lock);  // 等待 `produce()` 函数生产数据
    // 消费数据
}

Operasi atom:

Operasi atom ialah arahan CPU tunggal yang tidak boleh diganggu oleh urutan lain, memastikan pengubahsuaian kepada pembolehubah dikongsi adalah atom.

std::atomic<int> count;  // 定义原子变量

void incrementCount() {
    count++;  // 原子方式增加 `count`
}

Kes praktikal:

Pertimbangkan program berbilang benang berikut:

std::vector<int> numbers;  // 共享的整型数组

void addNumber(int n) {
    numbers.push_back(n);
}

int main() {
    std::thread t1(addNumber, 1);
    std::thread t2(addNumber, 2);
    t1.join();
    t2.join();
    
    std::cout << "Numbers in the vector: ";
    for (int n : numbers) {
        std::cout << n << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

Dalam contoh ini, numbers tatasusunan ialah sumber kongsi yang boleh diakses secara serentak oleh berbilang rangkaian. Jika langkah penyegerakan tidak diambil, keadaan perlumbaan mungkin berlaku, mengakibatkan kerosakan data.

Untuk mengakses tatasusunan dengan selamat, kita boleh menggunakan kunci mutex:

void addNumber(int n) {
    std::lock_guard<std::mutex> lock(mtx);  // 在访问数组前加锁
    numbers.push_back(n);
}

Dengan cara ini, hanya satu utas boleh mengakses tatasusunan pada satu masa, memastikan integriti data.

Output:

Numbers in the vector: 1 2 

Atas ialah kandungan terperinci Konsep utama pengaturcaraan berbilang benang C++ ialah bagaimana untuk menyegerakkan benang?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!