Версия для печати темы

#include <deque>
#include <boost/thread.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/thread/barrier.hpp>

using namespace std;
using namespace boost;

// число потоков со scoped_lock
// тест падает, если хотя бы один из них больше 1
#define NUMBER_OF_WRITERS_1        1
#define NUMBER_OF_READERS_1        1

// число потоков с lock/unlock
// может быть любое число потоков
#define NUMBER_OF_WRITERS_2        2
#define NUMBER_OF_READERS_2        2

typedef deque<long> deq_type;

// указатель на общий дек
deq_type *pdeq;

// мьютекс для защиты дека
mutex mt;

// барьеры используются для одновременного старта всех потоков
barrier barr1(NUMBER_OF_WRITERS_1+NUMBER_OF_READERS_1);
barrier barr2(NUMBER_OF_WRITERS_2+NUMBER_OF_READERS_2);

// флаг завершения работы потоков
bool stop_flag;

// заглушка 
void dummy()
{
}

// пишуший поток со scoped_lock
void writer1()
{
    barr1.wait();
    while(!stop_flag)
    {
        {
            mutex::scoped_lock(mt);
            pdeq->push_front(1);
        }
        this_thread::sleep(posix_time::milliseconds(10));
    }
}

// читающий поток со scoped_lock
void reader1()
{
    deq_type *pcopy;
    barr1.wait();
    while(!stop_flag)
    {
        if(pdeq->size() > 0)    
        {
            {
                mutex::scoped_lock(mt);
                pcopy = pdeq;
                pdeq = new deq_type();
            }

            deque<long>::iterator i;
            for(i=pcopy->begin(); i!=pcopy->end(); i++)
            {
                dummy();
            }

            pcopy->clear();
            delete pcopy;
        }
    }
    this_thread::sleep(posix_time::milliseconds(10));
}

// пишуший поток со lock/unlock
void writer2()
{
    barr2.wait();
    while(!stop_flag)
    {
        mt.lock();
        pdeq->push_front(1);
        mt.unlock();
        this_thread::sleep(posix_time::milliseconds(10));
    }
}

// читающий поток со lock/unlock
void reader2()
{
    deq_type *pcopy;
    barr2.wait();
    while(!stop_flag)
    {
        if(pdeq->size() > 0)    
        {
            mt.lock();
            pcopy = pdeq;
            pdeq = new deq_type();
            mt.unlock();

            deque<long>::iterator i;
            for(i=pcopy->begin(); i!=pcopy->end(); i++)
            {
                dummy();
            }

            pcopy->clear();
            delete pcopy;
        }
    }
    this_thread::sleep(posix_time::milliseconds(10));
}

int main()
{
    thread_group tg;

    // тест со scoped_lock
    // инициализируем дек
    pdeq = new deq_type();

    stop_flag = false;
    for(int i=0; i<NUMBER_OF_WRITERS_1; i++) tg.create_thread(writer1); 
    for(int i=0; i<NUMBER_OF_READERS_1; i++) tg.create_thread(reader1); 

    this_thread::sleep(posix_time::seconds(1));
    stop_flag = true;
    tg.join_all();

    if(pdeq != 0) 
    {
        pdeq->clear();
        delete pdeq;
    }

    // тест с lock/unlock

    // инициализируем дек
    pdeq = new deq_type();

    stop_flag = false;
    for(int i=0; i<NUMBER_OF_WRITERS_2; i++) tg.create_thread(writer2);
    for(int i=0; i<NUMBER_OF_READERS_2; i++) tg.create_thread(reader2);

    this_thread::sleep(posix_time::seconds(1));
    stop_flag = true;
    tg.join_all();

    if(pdeq != 0) 
    {
        pdeq->clear();
        delete pdeq;
    }
    return 0;
}