Qanday qilib iplar o'rtasidagi o'zaro ta'sirni…

C/C++ tilida o'zaro ta'sir va sinxronizatsiya uchun bir nechta asosiy mexanizmlar mavjud:

Mutexlar (Mutekslar): Bo'lishilgan resursga eksklyuziv kirishni ta'minlaydi. Muteksni olgan oqim, uni bo'shatguniga qadar boshqalarni bloklaydi.

#include <mutex>

std::mutex my_mutex;

void my_thread_function() {
    my_mutex.lock(); // Muteksni olish
    // Bo'lishilgan resurs bilan ishlash
    my_mutex.unlock(); // Muteksni bo'shatish
}

Yoki RAII bilan:

#include <mutex>
#include <lock_guard>

std::mutex my_mutex;

void my_thread_function() {
    std::lock_guard<std::mutex> lock(my_mutex); // Ob'ekt yaratilganda muteksni olish
    // Bo'lishilgan resurs bilan ishlash
    // G'oyatda, muteks avtomatik ravishda chiqish bilan bo'shatiladi
}

Semaforlar: Mutekslarning umumlashtirilishi. Ular hisoblagichni saqlaydi, bu esa belgilangan sondagi oqimlarning resursga bir vaqtning o'zida kirishiga imkon beradi.

#include <semaphore.h> // POSIX semaforlar uchun
#include <windows.h> // Windows semaforlar uchun

sem_t my_semaphore; // POSIX semafor

void my_thread_function() {
    sem_wait(&my_semaphore); // Semafor hisoblagichini kamaytirish, 0 bo'lsa bloklash
    // Resurs bilan ishlash
    sem_post(&my_semaphore); // Semafor hisoblagichini oshirish
}

(Eslatma: Standart C++ to'g'ridan-to'g'ri semaforlarni o'z ichiga olmaydi, ammo ular tizim kutubxonalari yoki uchinchi tomon kutubxonalari orqali mavjud.)

Shartli o'zgaruvchilar: Muayyan shartning ro'y berishini kutish uchun ishlatiladi va shu paytda muteksni bo'shatadi. Boshqa oqim shart bajarilganligini bildirish mumkin.

#include <mutex>
#include <condition_variable>

std::mutex my_mutex;
std::condition_variable my_cv;
bool condition_met = false;

void waiting_thread() {
    std::unique_lock<std::mutex> lock(my_mutex);
    my_cv.wait(lock, []{ return condition_met; }); // Shart bajarilishini kutish
    // Shart bajarildi, resurs bilan ishlash
}

void notifying_thread() {
    std::unique_lock<std::mutex> lock(my_mutex);
    condition_met = true;
    lock.unlock(); // Bildirishdan oldin muteksni bo'shatish (ixtiyoriy, ammo tavsiya etiladi)
    my_cv.notify_one(); // Bir oqimni xabar qilish
    // yoki
    // my_cv.notify_all(); // Barcha kutayotgan oqimlarni xabar qilish
}

Atomik operatsiyalar: O'zgaruvchilar ustida oddiy operatsiyalarni (masalan, inkrement, dekrement) yagona, bo'linmas harakat sifatida bajarishga imkon beradi, ochiq muteksni bloklamasdan.
```
#include <atomic>

std::atomic<int> counter(0);

void my_thread_function() {
    counter++; // Atomik inkrement
    // Yoki:
    // counter.fetch_add(1);
}
```

O'qish-yozish bloklari (Shared Mutexlar): Bir nechta oqimga ma'lumotlarni bir vaqtning o'zida o'qishga imkon beradi, lekin yozish uchun faqat bitta oqimga ruxsat beradi.

#include <shared_mutex> // C++17 va yuqori

std::shared_mutex my_shared_mutex;

void read_thread() {
    my_shared_mutex.lock_shared(); // O'qish uchun bloklash
    // Ma'lumotlarni o'qish
    my_shared_mutex.unlock_shared(); // O'qish uchun bo'shatish
}

void write_thread() {
    my_shared_mutex.lock(); // Yozish uchun bloklash (ekskluziv)
    // Ma'lumotlarni yozish
    my_shared_mutex.unlock(); // Yozish uchun bo'shatish
}

Barriarlar: Bir guruh oqimlarining, hammasi ma'lum bir nuqtaga yetguncha kutishini ta'minlaydi, so'ng davom etadi.

#include <barrier> // C++20

std::barrier sync_point(4); // 4 oqim uchun barriar

void my_thread_function() {
    // Barrierdan oldingi ish
    sync_point.arrive_and_wait(); // Hammasi barriergacha yetgach kutish
    // Barrierdan keyingi ish
}

Maxsus mexanizm tanlovi, o'zaro ta'sir va bo'lishilgan resurslarning tabiatiga bog'liq.

Qanday qilib iplar o'rtasidagi o'zaro ta'sirni sinxronlashtirish mumkin?