Имеет ли смысл создавать volatile переменную

void getParam(double &param){ //...
}

//...
{volatile double gain;
getParam((double&)gain);//...

#include "windows.h"
#include <iostream>
#include "process.h" 
using namespace std;
HANDLE event;
 
void Test1(void *);
void Test2(void *);
void Test3(void *);
 
void main()
{
    event = CreateEventA(NULL, TRUE, FALSE, "FirstStep");
 
    if (_beginthread(Test1, 1024, NULL) == -1)
        cout << "Error begin thread " << endl;
    //if (_beginthread(Test2, 1024, NULL) == -1)
    //  cout << "Error begin thread " << endl;
    //if (_beginthread(Test3, 1024, NULL) == -1)
    //  cout << "Error begin thread " << endl;
    if (event != NULL) {
        Sleep(500);
        SetEvent(event);
    Sleep(500);
        ResetEvent(event);
        //CloseHandle(event);
    }
    else {
        cout << "error create event" << endl;
    }
    getchar();
}
 
void Test1(void *)
{
    while (true) {
        //DWORD dwWaitResult{};
        //while (dwWaitResult != WAIT_OBJECT_0) {
            //dwWaitResult =
        WaitForSingleObject(event, INFINITE);
        //cout << "Test 1 TIMEOUT" << endl;
    //}
        cout << "Event Test 1 " << endl;
 
    }
    ///_endthread();
}
 
void Test2(void *)
{
    DWORD dwWaitResult{};
    while (dwWaitResult != WAIT_OBJECT_0) {//  WAIT_OBJECT_0    0x000000000L —осто¤ние указанного объекта сигнализирует.
        dwWaitResult = WaitForSingleObject(event, 1);
        cout << "Test 2 TIMEOUT" << endl;
    }
    cout << "Event Test 2 " << endl;
    _endthread();
}
 
void Test3(void *)
{
    DWORD dwWaitResult{};
    while (dwWaitResult != WAIT_OBJECT_0) {
        dwWaitResult = WaitForSingleObject(event, 1);
        cout << "Test 3 TIMEOUT" << endl;
    }
    cout << "Event Test 3 " << endl;
    _endthread();
}

//----------------
HANDLE e;
 
unsigned int __stdcall potoc(void* p) {
    char *pint = (char*)p;
    std::cout << pint << std::endl;
    Sleep(1000);
    SetEvent(e);// Устанавливает указанный объект события в сигнальное состояние.(Разрешает проход через пробку)
    //  -------- ResetEvent(e);  // Запрещает проход через пробку.
    //  --------  CloseHandle(e); //Хендл надо бы закрыть
    return 0;
}
 
//----------------  http://www.firststeps.ru/mfc/winapi/r.php?119
//------------- https://eax.me/winapi-threads/
// --------------------- https://**********************/questions/674933/
// ---------------- https://rsdn.org/article/cpp/cxx_events.xml
 
 
 
int main()
{
    const char * mas = "12345";
 
    e = CreateEventA(NULL, FALSE, FALSE, NULL);
 
    _beginthreadex(NULL, 0, &potoc, (void*)mas, 0, NULL);// Создает поток
 
    WaitForSingleObject(e, INFINITE);// Эта ху пробка. Она ждёт разрешения из потока -- SetEvent(e);
    //                INFINITE - ждёт вечно
    /*
Если WaitForSingleObject(e, INFINITE); использовать несколько раз в цикле потока,
                      то он после одного прохождения, лочит (SetEvent(e);)   снова
            ( Если второй параметр CreateEventA TRUE, функция создает объект события ручного сброса,
        который требует использования функции сброса ResetEvent) --- не лочит ---
    
Ожидание, пока указанный объект не окажется в сигнальном состоянии
или пока не истечет интервал времени ожидания (INFINITE - бесконечно).
Если указано ненулевое значение, функция ожидает,
пока объект не будет сигнализирован или интервал не истечет.
    */
    system("pause");
    return 0;
}

//----------------
HANDLE ev;
 
typedef struct {
    char word[21] = "Hello World!        ";
    int letter = 12345;
    short last_member{};
} z_data;
 
 
 
 
unsigned __stdcall MyThread(void *data)
{
    z_data *iptr = (z_data*)data;
    
printf("%s -- %d   %d\n", iptr->word, iptr->letter, iptr->last_member);
    
    Sleep(1000);
    SetEvent(ev);
    _endthread();
    return 0;
}
 
 
 
 
 
 
int main()
{
// z_data ems;// Переменная созданная таким образом имеет информацию и размер.
// ems.last_member = 5683;// Можно инициализировать здесь
 
    z_data ems{ "Hello fucked World! ", 7654, 543};// Переинициализировал. Надо соблюдать размер...
 
void *mem_ptr = malloc(sizeof(z_data));//  Это просто место на куче
    memcpy(mem_ptr, &ems, sizeof(ems));// Использую это место под структуру
//---------------------------------------------------
    ev = CreateEventA(NULL,// Указатель на структуру SECURITY_ATTRIBUTES.
        
        FALSE, /*Если этот параметр TRUE, функция создает объект события ручного сброса,
        который требует использования функции сброса ResetEvent,
        чтобы задать состояние события незначальным.
        Если этот параметр FALSE, функция создает объект события автоматического сброса,
        а система автоматически сбрасывает состояние события на незначаемое после выпуска одного потока ожидания.*/
        FALSE,/* Если этот параметр TRUE, сигнализируется начальное состояние объекта события;
    в противном случае оно не назначено.*/
        
        "lpName");// Имя объекта события 
//---------------------------------------------------
 
    for (int i = 0; i < 5; ++i) 
            {
        _beginthreadex(NULL, 0, MyThread, mem_ptr, 0, NULL);
 
        WaitForSingleObject(ev, INFINITE);
         //ResetEvent(ev);// Если первое CreateEventA(NULL,   FALSE то это делается автоматически (сброс)
            }
free(mem_ptr);
        return 0;
}

#include <iostream>
#include <thread>
#include <string>
#include <atomic>
 
int main()
{
    constexpr int steps=1000;
    constexpr int break_len=50;
    
    std::string s; //несинхронизированная переменная
    
    std::atomic<bool> flag{};
 
    std::thread t1([&flag,&s]
    {
        auto& fl = flag;
        for(int i=0; i<steps; )
        {
            if(!fl.load(std::memory_order_acquire))
            {
                ++i;
                s+='A';
                fl.store(true,std::memory_order_release);
            }
        }
    });
    
    std::thread t2([&flag,&s]
    {
        auto& fl = flag;
        for(int i=0; i<steps; )
        {
            if(fl.load(std::memory_order_acquire))
            {
                ++i;
                s+='B';
                fl.store(false,std::memory_order_release);
            }
        }
    });
    
    t2.join();
    t1.join();
    
    for(std::string_view v=s, sub; !(sub=v.substr(0,break_len)).empty(); v.remove_prefix(sub.size()))
    {
        std::cout<<sub<<'\n';
    }
}

#include <iostream>
#include <ranges>
#include <semaphore>
#include <string>
#include <string_view>
#include <thread>
 
int main()
{
    constexpr int steps = 1000;
    constexpr int break_len = 50;
 
    std::string s;
    std::binary_semaphore turn_a{1}, turn_b{0};
 
    auto worker = [&](std::binary_semaphore& in, std::binary_semaphore& out, char ch)
    {
        for (int i = 0; i < steps; ++i)
        {
            in.acquire();
            s += ch;
            out.release();
        }
    };
 
    {
        std::jthread t1{worker, std::ref(turn_a), std::ref(turn_b), 'A'};
        std::jthread t2{worker, std::ref(turn_b), std::ref(turn_a), 'B'};
    }
 
    for (auto chunk : s | std::views::chunk(break_len))
        std::cout << std::string_view(chunk) << '\n';
}