Асинхронность и Семафор

#include <iostream>
#include <semaphore.h>
#include <future>
#include <thread>
#include <vector>
#include <Windows.h>
 
using namespace std;
 
int main(int argc, const char *argv[])
{
    std::vector<std::future<void>> futures;
    sem_t semaphore1;
    
    sem_init(&semaphore1, 0, 1);    // 1 - бинарный семафор (can have 0 or 1)
    for (int i = 0; i < 10; ++i) { 
        futures.push_back(std::async(launch::async, [&semaphore1, i]
        {   
            Sleep(1000);       
            
            sem_wait(&semaphore1);  // decrements the semaphore, if 0 - then blocking sem.
            Sleep(100);
         
            cout <<"Hello world " << i << endl; 
              
            sem_post(&semaphore1);          // increments the semaphore that is being waited => smbd becomes awakened
        }));  
 
    }    
 
    for (auto &fut : futures) {
        fut.get();
        
    }
    
    sem_destroy(&semaphore1);
    return 0;
}

std::thread consumerThread (Consumer(bq, 0));

a=Consumer(bq, 0);
std::thread(threadFunction, std::ref(a);

// http://man.hubwiz.com/docset/C.docset/Contents/Resources/Documents/output/en/cpp/thread/async.html
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <future>
 
template <typename RAIter>
int parallel_sum(RAIter beg, RAIter end)
{
    auto len = end - beg;
    if(len < 1000)
        return std::accumulate(beg, end, 0);
 
    RAIter mid = beg + len/2;
    auto handle = std::async(std::launch::async,
                              parallel_sum<RAIter>, mid, end);
    int sum = parallel_sum(beg, mid);
    return sum + handle.get();
}
 
int main()
{
    std::vector<int> v(10000, 1);
    std::cout << "The sum is " << parallel_sum(v.begin(), v.end()) << '\n';
}

// https://eli.thegreenplace.net/2016/the-promises-and-challenges-of-stdasync-task-based-parallelism-in-c11/
int accumulate_block_worker_ret(int* data, size_t count) {
  throw std::runtime_error("something broke");
  return std::accumulate(data, data + count, 0);
}
 
...
 
{
  // Usage.
  std::vector<int> v{1, 2, 3, 4, 5, 6, 7, 8};
  try {
    std::future<int> fut = std::async(
        std::launch::async, accumulate_block_worker_ret, v.data(), v.size());
    std::cout << "use_worker_in_std_async computed " << fut.get() << "\n";
  } catch (const std::runtime_error& error) {
    std::cout << "caught an error: " << error.what() << "\n";
  }
}

 #include <bits/stdc++.h>
...
ios_base::sync_with_stdio(false);
cin.tie(NULL);