#include <boost/thread/thread.hpp>

#include <boost/lockfree/stack.hpp>

#include <iostream>

#include <boost/atomic.hpp>

boost::atomic_int producer_count();

boost::atomic_int consumer_count();

boost::lockfree::stack<int> stack();//多生产者多消费者无锁栈

const int iterations = ;

const int producer_thread_count = ;

const int consumer_thread_count = ;

void producer(void)

{

    for (int i = ; i != iterations; ++i) {

        int value = ++producer_count;

        while (!stack.push(value))

            ;

    }

}

boost::atomic<bool> done (false);

void consumer(void)

{

    int value;

    while (!done) {

        while (stack.pop(value))

            ++consumer_count;

    }

    while (stack.pop(value))

        ++consumer_count;

}

int main(int argc, char* argv[])

{

    using namespace std;

    cout << "boost::lockfree::stack is ";

    if (!stack.is_lock_free())

        cout << "not ";

    cout << "lockfree" << endl;

    boost::thread_group producer_threads, consumer_threads;

    for (int i = ; i != producer_thread_count; ++i)

        producer_threads.create_thread(producer);

    for (int i = ; i != consumer_thread_count; ++i)

        consumer_threads.create_thread(consumer);

    producer_threads.join_all();

    done = true;

    consumer_threads.join_all();

    cout << "produced " << producer_count << " objects." << endl;

    cout << "consumed " << consumer_count << " objects." << endl;

    getchar();

}