Многопоточность, _beginthreadex, ошибка ntdll.dll

 unsigned __stdcall potok(void* Param)
 {
//Собственно тут код может быть любой на частоту появления ошибки вообще никак не влияет,
// я Комментировал вообще все подряд, все равно лезет ошибка
 
     static int *p = (int*)Param;
 
     char buffer[100];
     wsprintf(buffer, "%u", *p);
     MessageBox(0, buffer, "", 0); 
 
     delete[] buffer;
 
     _endthreadex(0);
     return 0;
 }
 
int main()
{
    for (int i = 0; i < 50; i++)
    {
//      Sleep(900); // Если ставить паузу между запусками потоков, то проблема появляется значительно реже,
              // но появляется так, или иначе в любом случае, без паузы у меня в9 из 10 ловится ошибка.
 
        try
        {
            _beginthreadex(NULL, 0, &potok, (void*)&i, 0, NULL);  
        }
    
        catch (char *str)
        {
            printf("Error '%s'!\n", str);
        }
    }
 
    _endthreadex(0);
return 0;
}

mutex MUTEX;
int thread_count = 0;
 
void timer(int SecPause)
{
    std::this_thread::sleep_for(std::chrono::seconds(SecPause));
    throw std::runtime_error("Quit");
}
 
void f1(void* n)
{
    try
    {
        thread time(timer, 7);
        time.detach();
    }
    catch (const std::runtime_error& e)
    {
        return;
    }
 
    int p = (int)n;
    {
        std::lock_guard<std::mutex> _(MUTEX);
        ++thread_count;
    }
 
     char buffer[100];
     wsprintf(buffer, "%u", p);
     MessageBox(0, buffer, "", 0);
 
     {
        std::lock_guard<std::mutex> _(MUTEX);
        std::cout << "thread " << p << " working\n";
     }
}
 
 
int main()
{
    const int N = 3; // Количество потоков
    thread tt[N];
 
    for (int i = 0; i < N; i++)
    {
        cout << "Message from main Start_" << i << endl;
 
        tt[i] = thread(&f1, (void*)i);
        cout << "Potok" << i << " nat hand_" << tt[i].native_handle() << endl;
    }
 
    for (int i = 0; i < N; i++)
    {
 
        std::cout << "TRY TO FIN CORRECTLY " << i<<" \n";
        if (tt[i].joinable())
        {
            try
            {
                std::cout << "potok" << i << " nat hand_" << tt[i].native_handle() << endl;
                tt[i].join();
            }
            catch (int Error)
            {
                std::cout << "Sorry Error Here Destroy_"<<Error<< endl;
 
            }
        }
    }
    return 0;
}

#include <mutex>
#include <chrono>
#include <thread>
#include <iostream>
#include <Windows.h>
#include <condition_variable>
 
#include <vector>
#include <algorithm>
#include <iterator>
 
using namespace std;
mutex MUTEX;
 
const int N = 500; // Количество потоков
int SecPause = 10; // Устанавливаем таймер, таймаут
 
 
int thread_count = 0;
bool time_to_quit = false;
std::condition_variable cv;
std::vector<thread::id> thread_id;
 
void f1(void* n)
{
    int p = (int)n;
    //тут задаем вводные, чтобы не получилось ситуации при которой время операции дочернего потока получилась больше длины основного
    int pause = 0;
    int counts = 1000;
    int PauseMillisec = SecPause * 1000 - counts;
 
    //Получаем ID потока
    std::thread::id this_id = std::this_thread::get_id();
    
    {
        std::lock_guard<std::mutex> _(MUTEX);
        //Записываем ID потока в вектор, увеличиваем счетчик потоков
        thread_id.push_back(this_id);
        ++thread_count;
    }
    ///////////////////////////тут делаем что-то///////////////////
    char buffer[100];
    wsprintf(buffer, "%u", p);
    MessageBox(0, buffer, "", 0);
 
    while (true && pause < PauseMillisec)
    {
        pause += counts;
        {
            std::lock_guard<std::mutex> _(MUTEX);
            std::cout << "thread " << p << " working\n";
        }
        ///////////////////////////////////////////////////////////
        std::this_thread::sleep_for(std::chrono::milliseconds(500));
        ///////////////////////////////////////////////////////////
        std::lock_guard<std::mutex> _(MUTEX);
        if (time_to_quit)
        {
            break;
            
        }
    }
    ///////////////////////////тут делаем что-то///////////////////
    
    std::lock_guard<std::mutex> _(MUTEX);
    //
    auto it = std::find(thread_id.begin(), thread_id.end(), this_id);
    if (it == thread_id.end())
    {
        // видимо глюк элемента в векторе нет
    }
    else
    {
        //тут удаляем элемент из вектора
        auto index = std::distance(thread_id.begin(), it);
        thread_id.erase(thread_id.begin()+index);
    }
 
        //уменьшаем счетчик потоков
        --thread_count;
        cv.notify_all();
        //cv.notify_one();
 
        std::cout << "thread " << p << "__ID__" << this_id << "And Hndl _" << "" << "\n";
}
 
int main()
{
 
    
    thread tt[N];
    typedef std::chrono::steady_clock Clock;
 
    
    //Запускаем потоки в цикле
    for (int i = 0; i < N; i++)
    {
        cout << "Message from main Start_" << i << "\n" << endl;
        //передаем в поток переменную
        tt[i] = thread(&f1, (void*)i);
        
        //получаем Id потока и выводим на экран
        tt[i].get_id();
        cout << "Potok_" << i << " nat hand_" << tt[i].native_handle() <<" And ID is __" << tt[i].get_id() <<" \n";
    
        //  tt[i].detach();
    }
 
    //Работаем с таймером
    auto t0 = Clock::now();
    auto t1 = t0 + std::chrono::seconds(SecPause);
    
    std::unique_lock<std::mutex> lk(MUTEX);
    
    //Если количество потоков равно нулю, то таймер выключаем, если больше нуля,
    //ждем количество секунд заданное ранее
    {
            while (!time_to_quit && Clock::now() < t1)
            {
                if (thread_count > 0)
                {
                    std::cout << "The Nmbr of Threads running is _"<<thread_count<<endl;
                    cv.wait_until(lk, t1);
                }
                else 
                {
                    break; 
                    //return 0;
                }
            }
 
    }
    
    
    //Посылаем сигнал во все потоки
    time_to_quit = true;
    lk.unlock();
 
    //выводим на экран оповещалку
    std::cout << "Time Out ending HERE\n";
    std::cout << "TRY TO FIN FIN\n";
    
    
 
 
 
    //Работаем со всеми запущенными потоками по схеме:
    //Если в векторе есть не удаленный элемент, значит поток завис, убиваем его, иначе закрываемся корректно.
    for (int i = 0; i < N; i++)
        
    {
        
        std::lock_guard<std::mutex> _(MUTEX);
        if (std::find(thread_id.begin(), thread_id.end(), tt[i].get_id()) != thread_id.end())
        {
            /////////Удаляю по системному хэндлу////////////////////////////////////////////////////////////////////////////
            std::cout << "UUps Time is Out\n";
            std::cout << "Potok_" << i << " nat hand_" << tt[i].native_handle() << " will be Terminated \n";
            
            tt[i].detach();
            
            TerminateThread(tt[i].native_handle(), 0);
                        
                    std::cout << "Potok_" << i << " nat hand_" << tt[i].native_handle() << " was Terminated \n";
            
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
        }
        else
        {
    
            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            std::cout << "TRY TO FIN CORRECTLY" << i << " \n";
 
            if (tt[i].joinable())
            {
            std::cout << "potok_" << i << " nat hand_" << tt[i].native_handle() << " Try to Join\n";
            tt[i].join();
            std::cout << "potok_" << i << " nat hand_" << tt[i].native_handle() << " Was Joined" << endl;
            }
            
        }
        
    }
 
    return 0;
 
}

#include <mutex>
#include <chrono>
#include <thread>
#include <iostream>
#include <Windows.h>
#include <condition_variable>
 
#include <vector>
#include <algorithm>
#include <iterator>
 
using namespace std;
mutex MUTEX;
 
const int N = 5;    // Количество потоков
int SecPause = 5;   // Устанавливаем таймер, таймаут
 
int time_to_act = 1;// Таймаут чтоб нажать ОК, чтобы понять что поток будет завершен во время
 
int thread_count = 0;
bool time_to_quit = false;
bool vector_busy_thread = false;
bool vector_busy_main = false;
std::condition_variable cv;
 
std::vector<thread::id> thread_id;
 
 
void f1(void* n)
{
    int p = (int)n;
    //тут задаем вводные, чтобы не получилось ситуации при которой время операции дочернего потока получилась больше длины основного
    int pause = 0;
    int counts = 500;
    int PauseMillisec = (SecPause - time_to_act) * 1000;
 
    //Получаем ID потока
    std::thread::id this_id = std::this_thread::get_id();
 
    {
        //      std::lock_guard<std::mutex> _(MUTEX);
        
        //Записываем ID потока в вектор, увеличиваем счетчик потоков
        MUTEX.lock();
        thread_id.push_back(this_id);
        ++thread_count;
        MUTEX.unlock();
    }
 
 
    ///////////////////////////тут делаем что-то///////////////////
    char buffer[100];
    wsprintf(buffer, "%u", p);
    MessageBox(0, buffer, "", 0);
 
 
    if (time_to_quit !=1)
    //Время вышло, нажимать ОК уже поздновато, в цикл не заходим
    //Актуально для большого числа потоков, больше 300 в том случае,
    //если комп уже висит а ОК жамкнуть можно.
    //Но все работает и без дополнительной проверки на ура
    {
    while (true && pause < PauseMillisec)
    {
        pause += counts;
        {
                        std::cout << "thread_"<<p<<"_" << pause << " working\n";
        }
        ///////////////////////////////////////////////////////////
        std::this_thread::sleep_for(std::chrono::milliseconds(counts));
        ///////////////////////////////////////////////////////////
 
        if (time_to_quit)
        {
            break;
 
        }
    }
 
}
    ///////////////////////////тут делаем что-то///////////////////
 
 
 
    //Проверка блокировки вектора из главной функции
while (true)
{
 
    if (vector_busy_main != 0);
    {
        //
        MUTEX.lock();
        vector_busy_thread = true;
        MUTEX.unlock();
 
    /////////////////////////////////////////////////////////////////////
    //////Строку нельзя комментить ни в коем случае//////////////////////
        std::cout << "Vecto_B_T --TR " << vector_busy_thread <<endl;
    ////!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!////
    ////!!!!Фатальная ошибка программа выплевывается не понимаю!!!!//////
    /////////////////////////////////////////////////////////////////////
 
        
//      std::lock_guard<std::mutex> _(MUTEX);
 
        MUTEX.lock();
//          std::cout << "ThreadError Lock --TR__" <<p<< endl;;
            auto it = std::find(thread_id.begin(), thread_id.end(), this_id);
            if (it == thread_id.end())
            {
            // видимо глюк элемента в векторе нет
            }
            else
            {
            //тут удаляем элемент из вектора
            auto index = std::distance(thread_id.begin(), it);
            thread_id.erase(thread_id.begin() + index);
            }
        MUTEX.unlock();
        
        MUTEX.lock();
        vector_busy_thread = false;
        MUTEX.unlock();
 
        //уменьшаем счетчик потоков
        MUTEX.lock();
            --thread_count;
        MUTEX.unlock();
            break;
    }
 
}
 
    cv.notify_all();
//  std::cout << "thread " << p << "__ID__" << this_id << "And Hndl _" << "" << "\n";
}
 
 
 
int main()
{
 
    
    thread tt[N];
    typedef std::chrono::steady_clock Clock;
 
    //Запускаем потоки в цикле
    for (int i = 0; i < N; i++)
    {
        //передаем в поток переменную
        tt[i] = thread(&f1, (void*)i);
        
        //получаем Id потока и выводим на экран
        tt[i].get_id();
        cout << "Potok_" << i << " nat hand_" << tt[i].native_handle() <<" And ID is __" << tt[i].get_id() <<" \n";
    
        //  tt[i].detach();
    }
 
    //Работаем с таймером
    auto t0 = Clock::now();
    auto t1 = t0 + std::chrono::seconds(SecPause);
    
    std::unique_lock<std::mutex> lk(MUTEX);
 
 
    //Если количество потоков равно нулю, то таймер выключаем, если больше нуля,
    //ждем количество секунд заданное ранее
    {
            while (!time_to_quit && Clock::now() < t1)
            {
                if (thread_count > 0)
                {
//                  std::cout << "The Nmbr of Threads running is _"<<thread_count<<endl;
                    cv.wait_until(lk, t1);
                }
                else 
                {
                    lk.unlock();
                    break; 
 
                }
            }
 
    }
 
//Говорим потокам что время вышло
time_to_quit = true;
 
//До тех пор пока условие не выполнится будем ожидать в цикле и проверять наличие сразрешения на блокировку
while (true)
{
 
        if (vector_busy_thread !=1);
    {
            //Посылаем сигнал во все потоки о том что вектор будет заблокирован
            vector_busy_main = true;
            break;
    }
    
}
 
    //Работаем со всеми запущеными потоками по схеме:
    //Если в векторе есть не удаленный элемент, значит поток завис, убиваем его, иначе закрываемся корректно.
    for (int i = 0; i < N; i++)
        
    {
 
        vector_busy_main = true;
 
        if (std::find(thread_id.begin(), thread_id.end(), tt[i].get_id()) != thread_id.end())
        {
            /////////Удаляю по системному хэндлу////////////////////////////////////////////////////////////////////////////
 
//          std::cout << "Potok_" << i << " nat hand_" << tt[i].native_handle() << " will be Terminated \n";
            
            tt[i].detach();
            TerminateThread(tt[i].native_handle(), 0);
            
            //оповещаемся о том что поток удален
            std::cout << "Potok_" << i << " ID_" << tt[i].get_id() << " was Terminated \n";
 
                    //Чистим вектор
                    //////////////////////////////////////////////////////
                    auto it = std::find(thread_id.begin(), thread_id.end(), tt[i].get_id());
                    if (it == thread_id.end())
                    {
                        // видимо глюк элемента в векторе нет
                    }
                    else
                    {
                        //тут удаляем элемент из вектора
                        
                        auto index = std::distance(thread_id.begin(), it);
                        std::lock_guard<std::mutex> _(MUTEX);
                        thread_id.erase(thread_id.begin() + index);
                                            }
                    //////////////////////////////////////////////////////
                    
        }
        else
        {
            //Закрываем поток нормально  
            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
            if (tt[i].joinable())
            {
//          std::cout << "potok_" << i << " nat hand_" << tt[i].native_handle() << " Try to Join\n";
            tt[i].join();
            std::cout << "potok_" << i << " ID_" << tt[i].get_id() << " Was Joined" << endl;
            }
            
        }
        
        vector_busy_main = false;
    }
    
    //Чистим вектор, на всякий случай
    thread_id.clear();
    return 0;
 
}

#define _SCL_SECURE_NO_WARNINGS 
#define D_SCL_SECURE_NO_WARNINGS        
#define _CRT_SECURE_NO_WARNINGS         
 
#include <mutex>
#include <chrono>
#include <thread>
#include <iostream>
#include <Windows.h>
#include <condition_variable>
 
#include <vector>
#include <algorithm>
#include <iterator>
#include <atomic>
 
 
 
using namespace std;
mutex MUTEX;
 
const int N = 500;    // Количество потоков
int SecPause = 15;   // Устанавливаем таймер, таймаут
 
int time_to_act = 5; // Таймаут чтоб нажать ОК, чтобы понять что поток будет завершен во время
 
int thread_count = 0;
atomic<bool> time_to_quit = false;
atomic<bool> vector_busy_thread = false;
atomic<bool> vector_busy_main = false;
 
std::condition_variable cv;
 
std::vector<thread::id> thread_id;
 
 
void f1(void* n)
{
    int p = (int)n;
    //тут задаем вводные, чтобы не получилось ситуации при которой время операции дочернего потока получилась больше длины основного
    int pause = 0;
    int counts = 500;
    int PauseMillisec = (SecPause - time_to_act) * 1000;
 
    //Получаем ID потока
    std::thread::id this_id = std::this_thread::get_id();
 
    {
        //      std::lock_guard<std::mutex> _(MUTEX);
 
        //Записываем ID потока в вектор, увеличиваем счетчик потоков
        MUTEX.lock();
        thread_id.push_back(this_id);
        ++thread_count;
        MUTEX.unlock();
    }
 
 
    ///////////////////////////тут делаем что-то///////////////////
    char buffer[100];
    wsprintf(buffer, "%u", p);
    MessageBox(0, buffer, "", 0);
 
 
    if (time_to_quit != 1)
        //Время вышло, нажимать ОК уже поздновато, в цикл не заходим
        //Актуально для большого числа потоков, больше 300 в том случае,
        //если комп уже висит а ОК жамкнуть можно.
        //Но все работает и без дополнительной проверки на ура
    {
        while (true && pause < PauseMillisec)
        {
            pause += counts;
            {
                std::cout << "thread_" << p << "_" << pause << " working\n";
            }
            ///////////////////////////////////////////////////////////
            std::this_thread::sleep_for(std::chrono::milliseconds(counts));
            ///////////////////////////////////////////////////////////
 
            if (time_to_quit)
            {
                break;
 
            }
        }
 
    }
    ///////////////////////////тут делаем что-то///////////////////
 
//  std::cout << "vector_busy_main --TR " << vector_busy_main << endl;
 
    //Проверка блокировки вектора из главной функции
    while (time_to_quit == 0)
    {
        if (vector_busy_main == 0)
        {
//      if  (vector_busy_thread == 0)
        {
            // Локи не нужны булева проверка плюс атомики
//          MUTEX.lock();
            vector_busy_thread = true;
//          MUTEX.unlock();
 
            /////////////////////////////////////////////////////////////////////
//          std::cout << "Vecto_B_T --TR "<<p<<"__" << vector_busy_thread << endl;
            /////////////////////////////////////////////////////////////////////
 
 
            //      std::lock_guard<std::mutex> _(MUTEX);
 
            // На всякий случай мютекс, обращение к вектору
            MUTEX.lock();
            //          std::cout << "ThreadError Lock --TR__" <<p<< endl;;
            auto it = std::find(thread_id.begin(), thread_id.end(), this_id);
            if (it == thread_id.end())
            {
                // видимо глюк элемента в векторе нет
            }
            else
            {
                //тут удаляем элемент из вектора
                auto index = std::distance(thread_id.begin(), it);
                thread_id.erase(thread_id.begin() + index);
            }
            MUTEX.unlock();
 
//          MUTEX.lock();
            vector_busy_thread = false;
//          MUTEX.unlock();
 
            //уменьшаем счетчик потоков
//          MUTEX.lock();
            --thread_count;
//          MUTEX.unlock();
            break;
        }
        
        }
    }
 
    cv.notify_all();
    //  std::cout << "thread " << p << "__ID__" << this_id << "And Hndl _" << "" << "\n";
}
 
 
 
int main()
{
 
 
    thread tt[N];
    typedef std::chrono::steady_clock Clock;
 
    //Запускаем потоки в цикле
    for (int i = 0; i < N; i++)
    {
        //передаем в поток переменную
        tt[i] = thread(&f1, (void*)i);
 
        //получаем Id потока и выводим на экран
        tt[i].get_id();
        cout << "Potok_" << i << " nat hand_" << tt[i].native_handle() << " And ID is __" << tt[i].get_id() << " \n";
 
        //  tt[i].detach();
    }
 
    //Работаем с таймером
    auto t0 = Clock::now();
    auto t1 = t0 + std::chrono::seconds(SecPause);
 
    std::unique_lock<std::mutex> lk(MUTEX);
 
 
    //Если количество потоков равно нулю, то таймер выключаем, если больше нуля,
    //ждем количество секунд заданное ранее
    {
        while (!time_to_quit && Clock::now() < t1)
        {
            if (thread_count > 0)
            {
                //                  std::cout << "The Nmbr of Threads running is _"<<thread_count<<endl;
                cv.wait_until(lk, t1);
            }
            else
            {
                lk.unlock();
                break;
 
            }
        }
 
    }
 
    //Говорим потокам что время вышло
    time_to_quit = true;
 
    //До тех пор пока условие не выполнится будем ожидать в цикле и проверять наличие сразрешения на блокировку
    while (true)
    {
 
        if (vector_busy_thread != 1)
        {
            //Посылаем сигнал во все потоки о том что вектор будет заблокирован
            vector_busy_main = true;
            break;
        }
 
    }
 
    vector_busy_main = true;
    //Работаем со всеми запущеными потоками по схеме:
    //Если в векторе есть не удаленный элемент, значит поток завис, убиваем его, иначе закрываемся корректно.
    for (int i = 0; i < N; i++)
 
    {
        while (true)
        {
            if (vector_busy_thread == 0)
            {
            
 
                if (std::find(thread_id.begin(), thread_id.end(), tt[i].get_id()) != thread_id.end())
                {
                    /////////Удаляю по системному хэндлу////////////////////////////////////////////////////////////////////////////
 
                    //          std::cout << "Potok_" << i << " nat hand_" << tt[i].native_handle() << " will be Terminated \n";
 
                    tt[i].detach();
                    TerminateThread(tt[i].native_handle(), 0);
 
                    //оповещаемся о том что поток удален
                    std::cout << "Potok_" << i << " ID_" << tt[i].get_id() << " was Terminated \n";
 
                    //Чистим вектор
                    //////////////////////////////////////////////////////
                    auto it = std::find(thread_id.begin(), thread_id.end(), tt[i].get_id());
                    if (it == thread_id.end())
                    {
                        // видимо глюк элемента в векторе нет
                    }
                    else
                    {
                        //тут удаляем элемент из вектора
 
                        auto index = std::distance(thread_id.begin(), it);
                        std::lock_guard<std::mutex> _(MUTEX);
                        thread_id.erase(thread_id.begin() + index);
                    }
                    //////////////////////////////////////////////////////
                }
                else
                {
                    //Закрываем поток нормально 
                    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
                    if (tt[i].joinable())
                    {
                        //          std::cout << "potok_" << i << " nat hand_" << tt[i].native_handle() << " Try to Join\n";
                        tt[i].join();
                        std::cout << "potok_" << i << " ID_" << tt[i].get_id() << " Was Joined" << endl;
                    }
                }
            break;
            }
            else { std::this_thread::sleep_for(std::chrono::milliseconds(30)); }
        }
    }
 
    vector_busy_main = false;
    //Чистим вектор, на всякий случай
    thread_id.clear();
    return 0;
 
}

#include <windows.h>
#include <process.h>
#include <iostream>
 
unsigned __stdcall threadFunction(void* Param)
{
    // .. 
    return 0;
}
 
int main()
{
 
    const int N = 150;
    HANDLE h[N];
    for (int i = 0; i < N; i++)
    {
        h[i] = (HANDLE)_beginthreadex(NULL, 0, &threadFunction, (void*)i, 0, NULL);
    }
 
    // Или же лучше через WaitForMultipleObjects()  
    for (int i = 0; i < N; i++)
    {
        WaitForSingleObject(h[i], INFINITE); // вставляем последовательное ожидание и проблемы нет
    }
 
    return 0;
}

#include <windows.h>
#include <process.h>
#include <iostream>
#include <chrono>
#include <thread>
 
 
const int N = 150;  // Количество потоков
int SecPause = 15;  // Устанавливаем таймер, таймаут
 
int time_to_act = 3;// Время чтоб нажать ок, чотобы понять что поток будет завершен во время
 
 
unsigned __stdcall threadFunction(void* Param)
{
    int p = (int)Param;
    //тут задаем вводные, чтобы не получилось ситуации при которой время операции дочернего потока получилась больше длины основного
    int pause = 0;
    int counts = 500;
    int PauseMillisec = (SecPause - time_to_act) * 1000;
 
    ///////////////////////////тут делаем что-то///////////////////
    char buffer[100];
    wsprintf(buffer, "%u", p);
    MessageBox(0, buffer, "", 0);
 
        //Время вышло, нажимать ОК уже поздновато, в цикл не заходим
        //Актуально для большого числа потоков, больше 300 в том случае,
        //если комп уже висит а ОК жамкнуть можно.
        //Но все работает и без дополнительной проверки на ура
    {
        while (true && pause < PauseMillisec)
        {
            pause += counts;
            {
                std::cout << "thread_" << p << "_" << pause << " working\n";
            }
            ///////////////////////////////////////////////////////////
            std::this_thread::sleep_for(std::chrono::milliseconds(counts));
            ///////////////////////////////////////////////////////////
        }
    }
    return 0;
}
 
int main()
{
 
 
    HANDLE h[N];
    for (int i = 0; i < N; i++)
    {
        h[i] = (HANDLE)_beginthreadex(NULL, 0, &threadFunction, (void*)i, 0, NULL);
    }
 
    // Или же лучше через WaitForMultipleObjects()  
    for (int i = 0; i < N; i++)
    {
        WaitForSingleObject(h[i], (1000*SecPause)); // вставляем последовательное ожидание и проблемы нет
    }
 
    return 0;
}

#include <Windows.h>
#include <process.h>
#include <cstdio>
 
int const g_NumThreads = 100;
 
HANDLE volatile g_hQuitEvent = NULL;
LONG volatile g_Counter = g_NumThreads;
 
//
// Функция потока.
//
unsigned int CALLBACK ThreadProc(PVOID Param)
{
    printf("Thread ID = %lu\r\n", GetCurrentThreadId());
 
    Sleep(4000); // Тут может быть какая-то полезная работа.
 
    //
    // Уменьшаем счетчик потоков. Если 0, то взводим событие.
    //
 
    if (0 == _InterlockedDecrement(&g_Counter)) {
        SetEvent(g_hQuitEvent);
    }
 
    printf("Bye!\r\n");
 
    return 0;
}
 
//
// Точка входа.
//
int main()
{
    HANDLE Handles[g_NumThreads] = {0};
 
    //
    // Создаем сигнальное событие.
    //
 
    g_hQuitEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
    if (!g_hQuitEvent) {
        printf("[ERROR] CreateEventW failed, err = 0x%.8lx.\r\n", GetLastError());
        goto Finish;
    }
 
    //
    // Запускаем потоки.
    //
 
    for (int i = 0; i < g_NumThreads; ++i)
    {
        Handles[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, (PVOID)i, 0, NULL);
        if (!Handles[i]) {
            printf("_beginthreadex failed.\r\n");
            goto Finish;
        }
    }
 
    //
    // Ждем, пока событие не будет переведено в сигнальное состояние.
    //
    WaitForSingleObject(g_hQuitEvent, INFINITE);
 
Finish:
 
    //
    // Очистка ресурсов.
    //
 
    for (int i = 0; i < g_NumThreads; ++i) {
        if (Handles[i]) {
            WaitForSingleObject(Handles[i], INFINITE);
            CloseHandle(Handles[i]);
        }
    }
 
    if (g_hQuitEvent) {
        CloseHandle(g_hQuitEvent);
    }
 
    return 0;
}