Я предоставлю вам несколько примитивов синхронизации C++ вместе с примерами кода. Вот некоторые часто используемые методы:

1. Мьютекс:
   Мьютекс — это примитив взаимного исключения, который позволяет только одному потоку одновременно получать доступ к общему ресурсу. Он обеспечивает механизм блокировки для обеспечения эксклюзивного доступа к критическому разделу.

#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx;
void sharedResourceAccess()
{
    std::lock_guard<std::mutex> lock(mtx);
    // Critical section
    // Access the shared resource safely
}
int main()
{
    std::thread t1(sharedResourceAccess);
    std::thread t2(sharedResourceAccess);
    t1.join();
    t2.join();
    return 0;
}

2. Семафор:
   Семафор — это примитив синхронизации, который позволяет указанному количеству потоков одновременно получать доступ к общему ресурсу. Он поддерживает счетчик и блокирует потоки, если счетчик достигает нуля.

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
std::mutex mtx;
std::condition_variable cv;
int count = 0;
const int MAX_COUNT = 5;
void sharedResourceAccess()
{
    std::unique_lock<std::mutex> lock(mtx);
    while (count >= MAX_COUNT)
    {
        cv.wait(lock);
    }
    count++;
    // Critical section
    // Access the shared resource safely
    count--;
    cv.notify_all();
}
int main()
{
    std::thread t1(sharedResourceAccess);
    std::thread t2(sharedResourceAccess);
    t1.join();
    t2.join();
    return 0;
}

3. Блокировка чтения и записи.
   Блокировка чтения и записи позволяет нескольким потокам одновременно читать общий ресурс, но только одному потоку разрешено записывать в ресурс исключительно.

#include <iostream>
#include <thread>
#include <shared_mutex>
std::shared_mutex rwMutex;
int sharedResource = 0;
void readerThread()
{
    std::shared_lock<std::shared_mutex> lock(rwMutex);
    // Read shared resource safely
    std::cout << "Shared Resource: " << sharedResource << std::endl;
}
void writerThread()
{
    std::unique_lock<std::shared_mutex> lock(rwMutex);
    // Write to shared resource safely
    sharedResource = 42;
}
int main()
{
    std::thread t1(readerThread);
    std::thread t2(writerThread);
    t1.join();
    t2.join();
    return 0;
}

4. Переменная условия:
   Переменная условия используется для синхронизации выполнения потоков на основе определенных условий. Прежде чем продолжить, потоки могут дождаться, пока условие станет истинным.

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
std::mutex mtx;
std::condition_variable cv;
bool condition = false;
void waitingThread()
{
    std::unique_lock<std::mutex> lock(mtx);
    while (!condition)
    {
        cv.wait(lock);
    }
// Condition is true, proceed
    std::cout << "Condition is true!" << std::endl;
}
void notifyingThread()
{
    std::this_thread::sleep_for(std::chrono::seconds(2));
    {
        std::lock_guard<std::mutex> lock(mtx);
        condition = true;
    }
    cv.notify_all();
}
int main()
{
    std::thread t1(waitingThread);
    std::thread t2(notifyingThread);
    t1.join();
    t2.join();
    return 0;
}

Это всего лишь несколько примеров примитивов синхронизации в C++. В зависимости от ваших конкретных требований вы можете изучить более сложные методы, такие как барьеры, переменные условия с таймаутами и т. д.