#include <cstdatomic>
#include <vector>
#include <iostream>

std::atomic_bool g_data_init;
std::vector<int> g_data

void tread1()
{
    g_data.push_back(0);
    g_data_init.store(true, std::memory_model_release);
}

void tread2()
{
    while (false == g_data_init.load(std::memory_model_acquire)) {}
    std::cout << g_data[0];
}

R>

The WaitForMultipleObjects function can specify handles of any of the following object types in the lpHandles array:

Change notification
Console input
Event
Job
Memory resource notification
Mutex
Process
Semaphore
Thread
Waitable timer

class Gatherer
{
public:
    void operator()()
    {
        while(boost::optional<Data> data = readData())
        {
            boost::unique_lock<boost::mutex> lock(m_mutexSignal);
            m_signal(*data);
        }
    }

    boost::signals::connection addCallback(boost::function<void (Data const &)> callback)
    {
        boost::unique_lock<boost::mutex> lock(m_mutexSignal);
        return m_signal.connect(callback);
    }

private:
    boost::mutex m_mutexSignal;
    boost::signal<void (Data const &)> m_signal;
};

class Processor
{
public:
    Processor(): m_shouldStop(false)
    {
    }

    void operator()()
    {
        boost::unique_lock<boost::mutex> lock(m_mutex);

        while(1)
        {
            if(m_shouldStop)
            {
                return;
            }
            if(m_data)
            {
                doSomething(*m_data);
                m_data = boost::none;
            }
            m_ping.wait(lock);
        }
    }

    void incoming(Data const& data)
    {
        boost::unique_lock<boost::mutex> lock(m_mutex);
        m_data = data;
        m_ping.notify_all();
    }

    void stop()
    {
        boost::unique_lock<boost::mutex> lock(m_mutex);
        m_shouldStop = true;
        m_ping.notify_all();
    }

private:
    bool m_shouldStop;
    boost::optional<Data> m_data;

    boost::mutex m_mutex;
    boost::condition_variable_any m_ping;
};

boost::unique_lock<boost::mutex> lock(m_mutex);
while(1)
{
    m_ping.wait(lock, boost::bind(&boost::optional<Data>::is_initialized, m_data); // или boost::lambda::var(m_data)
    doSomething(*m_data);
    m_data = boost::none;
}

//на глазок
struct some_mega_struct{ int i_; };

int ThreadFoo(void* pContext)
{
some_mega_struct* p = static_cast<some_mega_struct*>(pContext);
(pContext->i)++;
return 0;
}


HANDLE hVec[16];
some_mega_struct vec_some_mega_struct[16];


for (size_t i = 0; i != 16; ++i )
hVec[i] = CreateThread(...,&vec_some_mega_struct[i]);

WFMO(sizeof(hVec) ,&hVec[0],); // вот тут дождались

_>for (size_t i = 0; i != 16; ++i )
_>hVec[i] = CreateThread(...,&vec_some_mega_struct[i]);
_>WFMO(sizeof(hVec) ,&hVec[0],); // вот тут дождались
_>

for(std::thread& t : pool) // C++09
{
    t.join();
}

RO>>for(std::thread& t : pool) // C++09
RO>>{
RO>>    t.join();
RO>>}
RO>>

void f(void *)
{
    Sleep(100);
}

std::vector<HANDLE> pool(N);
for(std::size_t i = 0; i < N; ++i)
{
    pool[i] = (HANDLE)_beginthreadex(0, 0, f, 0, 0, 0);
}

// вариант 1
WaitForMultipleObjects(N, &pool.begin(), TRUE, INFINITE);

// вариант 2
for(std::size_t i = 0; i < N; ++i)
{
    WaitForSingleObject(pool[i], INFINITE);
}