Потоко-безопасная Очередь

#include <iostream>
#include <thread>
#include <condition_variable>
#include  <mutex>
#include <chrono>
#include <queue>
 
using namespace std;
 
  bool bDone;
  mutex m;
  std::condition_variable cv;
 
int main() {
    int c = 0;
    bool done = false;
    queue<int> goods;
 
    thread producer([&]() {
        std::lock_guard<mutex> lock(m);
        for (int i = 0; i < 500; ++i) {            
            goods.push(i);
            c++;
            cv.notify_one();
        }
 
        done = true;
    });
 
    thread consumer([&]() {
        std::unique_lock<mutex> lock(m);
        while (!done) {
            while (!goods.empty()) {
                goods.pop();
                c--;
                while (!bDone) cv.wait(lock);
            }
        }
    });
 
    producer.join();
    consumer.join();
    cout << "Net: " << c << endl;
}

// https://stackoverflow.com/questions/57074998/condition-variable-with-a-while-loop-in-thread-in-c
 
// ПРОБЛЕМА ПОСЛЕДНЕГО ЭЛЕМЕНТА В producer-consumer queue на 2core-CPU, т.е. 2 consumer'a по коду
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <vector>
#include <chrono>
#include <atomic>
 
using namespace std;
 
int main() {
    int n_core = std::thread::hardware_concurrency();
    vector<std::thread> workers;
    volatile int max = 5;
    volatile atomic<int> count = 0;
    std::condition_variable cv;
    std::mutex m, mp;
    int timecalled = 0;
 
    // consumers max qty
    for (int i = 0; i < n_core; i++) {
        workers.emplace_back(std::thread{[&max, &count, &m, &cv, &mp]() {
            while (true) {                
                std::unique_lock<std::mutex> lk{m};
 
                {
                    std::lock_guard<mutex> lock(mp);
                    std::cout << "t_id " << std::this_thread::get_id() << " cv wait start " << std::endl;
                }
                // ждет условную переменную, используя лямбда-функцию в качестве предиката и !! возвращает объект блокировки вызывающей программе
                cv.wait(lk, [&max, &count]() { return count > 0 || max==0; });
                //if(max<=0) break;
                // 1.           // count check решает ПРОБЛЕМУ ПОСЛЕДНЕГО ЭЛЕМЕНТА - чтобы 2й поток не уменьшил count ЕЩЁ БОЛЬШЕ до -1
                if ( count > 0 ) {
                
                    {
                        std::lock_guard<mutex> lock(mp);
                        std::cout << "t_id " << std::this_thread::get_id() << " consumer - " << count << std::endl;
                    }
                    count--;
                    
                    {
                        std::lock_guard<mutex> lock(mp);
                        std::cout << "t_id " << std::this_thread::get_id() << " notify dec" << std::endl;
                    }
                    
                    cv.notify_one();
                    //this_thread::sleep_for(chrono::milliseconds(1));
                }
                // 2. finish_check anyway
                if(max==0) {
                    {
                        std::lock_guard<mutex> lock(mp);
                        std::cout << "t_id " << std::this_thread::get_id() << " finished " << std::endl;
                    }
                    break;
                }
            }
        }});
    }
 
    // producing from main
    while (max > 0) {        
        std::unique_lock<std::mutex> lk{m};
               
        cv.wait(lk, [&count]() { return count == 0; });
        
        count++;
        max--;
        timecalled++;
        std::cout << "MAIN t_id " << std::this_thread::get_id() << " notify inc" << std::endl;
 
        cv.notify_one();
        //this_thread::sleep_for(chrono::milliseconds(1));
    }
 
    for (auto &w : workers) {
        w.join();
    }
 
    std::cout << "qty all:" << timecalled << std::endl; // must be equal to max
    std::cout << "count now: " << count << std::endl; // must be zero !!!
    
    return 0;
}

 // каким образом мы можем передать исключение из одного потока в другой:
void worker(std::promise<void> & p) {
    try {
        throw std::runtime_error("exception from thread");
    } catch (...) {
        p.set_exception(std::current_exception());
    }
}
 
void checkThreadAndException() {
    std::promise<void> p;
    auto result = p.get_future();
 
    std::thread t(worker, ref(p));
    t.detach();
 
    try {
        result.get();
    } catch (const std::runtime_error & e) {
        std::cout << "runtime error catched from async worker" << std::endl;
    }
}
 
int main()
{
    checkThreadAndException();
    return 0;
}

// https://tproger.ru/problems/safe-threads-in-cpp/
// Безопасность потоков в С++
 
/*
получается, что стандартная библиотека противоречит принципу RAII — при создании std::thread мы сами должны позаботиться о корректном управлении ресурсами, 
то есть явно вызвать join или detach. 
*/
 
#include <iostream>
#include <thread>
#include <atomic>
#include <vector>
#include <algorithm>
#include <exception>
 
using namespace std;
 
 
class Consumer {
private:
    std::atomic<bool> exit_flag; // флаг для синхронизации (опционально)
    std::thread thr;
public:
     Consumer()
          : exit_flag(false)
          , thr( &Consumer::run, this )
     {
         // после создания потока не делайте тут ничего, что бросает исключение,
         // поскольку в этом случае не будет вызван деструктор объекта Consumer,
         // поток не будет завершен, а программа упадет
     }
 
     ~Consumer() noexcept {
          exit_flag = true; // говорим потоку остановиться
          thr.join();
     }
    void run() {
        while (!exit_flag) {
            // делаем что-нибудь
            //std::cout << "t_id " << std::this_thread::get_id() << " consumer - " <<  std::endl;
            printf("t_id %d\n",std::this_thread::get_id());
            try{
                throw runtime_error ("Error: in try block. \n");
            }
            catch (const std::exception& e) {
                //rethrow runtime_error ("Error: ");
                printf("Failed to finish fx: Ignoring exception in catch block -- %s", e.what());
            break;
            }            
        }
    }
};
 
int main(int argc, const char *argv[])
{
    //try   {
        Consumer c;
        c.run();
    //} 
    //catch (const char* exception)
    //{
    //  std::cerr << "Failed to finish thread - Ignoring exception! " << exception << '\n';
    //}
 
    return 0;
}