İplər arasında qarşılıqlı əlaqəni necə…

C/C++-də qarşılıqlı əlaqə və sinxronizasiya üçün bir neçə əsas mexanizm mövcuddur:

Mutexlər (Mutual Exclusions): Paylaşılan resursa eksklüziv giriş təmin edir. Mutex-i ələ alan bir thread, onu buraxana qədər digər thread-lərin onu ələ keçirməsinə mane olur.

#include <mutex>

std::mutex my_mutex;

void my_thread_function() {
    my_mutex.lock(); // Mutex-i ələ keçirmək
    // Paylaşılan resursla işləmək
    my_mutex.unlock(); // Mutex-i buraxmaq
}

Yaxud RAII ilə:

#include <mutex>
#include <lock_guard>

std::mutex my_mutex;

void my_thread_function() {
    std::lock_guard<std::mutex> lock(my_mutex); // Obraz yaradılarkən mutex-i ələ keçirmək
    // Resursla işləmək
    // Mutex avtomatik olaraq scope-dan çıxarkən buraxılır
}

Semaforlar (Semaphores): Mutexlərin ümumiləşdirilməsi. Sayğac saxlayır və bu sayğacın dəyəri ilə eyni anda neçə thread-in resursa daxil ola biləcəyini müəyyən edir.

#include <semaphore.h> // POSIX semaforlar üçün
#include <windows.h> // Windows semaforlar üçün

sem_t my_semaphore; // POSIX semaforu

void my_thread_function() {
    sem_wait(&my_semaphore); // Sayğacı azaldır, 0 olarsa bloklayır
    // Resursla işləmək
    sem_post(&my_semaphore); // Sayğacı artırır
}

(Qeyd: C++ standartında semaforlar birbaşa daxil edilmir, lakin sistem kitabxanaları və ya üçüncü tərəf kitabxanaları vasitəsilə mövcuddur.)

Şərti dəyişənlər (Condition Variables): Bir thread-in müəyyən bir şərtin baş verməsini gözləməsinə imkan verir və bu zaman mutex-i sərbəst buraxır. Digər thread gözləyənə şərtin yerinə yetdiyini xəbərdar edə bilər.

#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; }); // Şərtin yerinə yetməsini gözləyir
    // Şərt yerinə yetdi, resursla işləmək
}

void notifying_thread() {
    std::unique_lock<std::mutex> lock(my_mutex);
    condition_met = true;
    lock.unlock(); // Bildiriş vermədən əvvəl mutex-i sərbəst buraxmaq (tövsiyə olunur)
    my_cv.notify_one(); // Bir gözləyən thread-i xəbərdar et
    // və ya
    // my_cv.notify_all(); // Bütün gözləyən thread-ləri xəbərdar et
}

Atomar əməliyyatlar (Atomic Operations): Sadə əməliyyatları (məsələn, artım, azalma) bir bütün kimi yerinə yetirməyə imkan verir, və bu, açıq şəkildə mutex istifadə etmədən edilir.
```
#include <atomic>

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

void my_thread_function() {
    counter++; // Atomik artım
    // və ya:
    // counter.fetch_add(1);
}
```

Oxuma-Yazma Lock-ləri (Shared Mutexes): Bir neçə thread-in eyni zamanda məlumatları oxumasına, lakin yalnız birinin yazmasına imkan verir.

#include <shared_mutex> // C++17 və yuxarı

std::shared_mutex my_shared_mutex;

void read_thread() {
    my_shared_mutex.lock_shared(); // Oxuma üçün lock
    // Məlumatların oxunması
    my_shared_mutex.unlock_shared(); // Oxuma üçün unlock
}

void write_thread() {
    my_shared_mutex.lock(); // Yazma üçün lock (exklüziv)
    // Məlumatların yazılması
    my_shared_mutex.unlock(); // Yazma üçün unlock
}

Barierlər (Barriers): Bir qrup thread-in müəyyən bir nöqtəyə çatmasını gözləməsinə imkan verir və hamısı oraya çatdıqdan sonra davam edir.

#include <barrier> // C++20

std::barrier sync_point(4); // 4 thread üçün barrier

void my_thread_function() {
    // Barrier-dən əvvəlki işlər
    sync_point.arrive_and_wait(); // Hamı barrier-ə çatana qədər gözləyir
    // Barrier-dən sonra işlər
}

Seçim, qarşılıqlı əlaqənin və paylaşılan resursların xarakterinə görə asılıdır.

İplər arasında qarşılıqlı əlaqəni necə sinxronlaşdırmaq olar?