Boost lockfree deque 生产者与消费者多对多线程应用

　　boost库中有一个boost::lockfree::queue类型的 队列，对于一般的需要队列的程序，其效率都算不错的了，下面使用一个用例来说明。

　　程序是一个典型的生产者与消费者的关系，都可以使用多线程，其效率要比使用上层的互斥锁要快很多，因为它直接使用底层的原子操作来进行同步数据的。

　　freedeque.h

#pragma once#ifndef INCLUDED_UTILS_LFRINGQUEUE  
#define INCLUDED_UTILS_LFRINGQUEUE  

#define _ENABLE_ATOMIC_ALIGNMENT_FIX  
#define ATOMIC_FLAG_INIT 0  


#pragma once  


#include <vector>  
#include <mutex>  
#include <thread>  
#include <atomic>  
#include <chrono>  
#include <cstring>  
#include <iostream>  

// Lock free ring queue   

template < typename _TyData, long _uiCount = 100000 >
class lfringqueue
{
public:
    lfringqueue(long uiCount = _uiCount) : m_lTailIterator(0), m_lHeadIterator(0), m_uiCount(uiCount)
    {
        m_queue = new _TyData*[m_uiCount];
        memset(m_queue, 0, sizeof(_TyData*) * m_uiCount);
    }

    ~lfringqueue()
    {
        if (m_queue)
            delete[] m_queue;
    }

    bool enqueue(_TyData *pdata, unsigned int uiRetries = 1000)
    {
        if (NULL == pdata)
        {
            // Null enqueues are not allowed  
            return false;
        }

        unsigned int uiCurrRetries = 0;
        while (uiCurrRetries < uiRetries)
        {
            // Release fence in order to prevent memory reordering   
            // of any read or write with following write  
            std::atomic_thread_fence(std::memory_order_release);

            long lHeadIterator = m_lHeadIterator;

            if (NULL == m_queue[lHeadIterator])
            {
                long lHeadIteratorOrig = lHeadIterator;

                ++lHeadIterator;
                if (lHeadIterator >= m_uiCount)
                    lHeadIterator = 0;

                // Don't worry if this CAS fails.  It only means some thread else has  
                // already inserted an item and set it.  
                if (std::atomic_compare_exchange_strong(&m_lHeadIterator, &lHeadIteratorOrig, lHeadIterator))
                {
                    // void* are always atomic (you wont set a partial pointer).  
                    m_queue[lHeadIteratorOrig] = pdata;

                    if (m_lEventSet.test_and_set())
                    {
                        m_bHasItem.test_and_set();
                    }
                    return true;
                }
            }
            else
            {
                // The queue is full.  Spin a few times to check to see if an item is popped off.  
                ++uiCurrRetries;
            }
        }
        return false;
    }

    bool dequeue(_TyData **ppdata)
    {
        if (!ppdata)
        {
            // Null dequeues are not allowed!  
            return false;
        }

        bool bDone = false;
        bool bCheckQueue = true;

        while (!bDone)
        {
            // Acquire fence in order to prevent memory reordering   
            // of any read or write with following read  
            std::atomic_thread_fence(std::memory_order_acquire);
            //MemoryBarrier();  
            long lTailIterator = m_lTailIterator;
            _TyData *pdata = m_queue[lTailIterator];
            //volatile _TyData *pdata = m_queue[lTailIterator];              
            if (NULL != pdata)
            {
                bCheckQueue = true;
                long lTailIteratorOrig = lTailIterator;

                ++lTailIterator;
                if (lTailIterator >= m_uiCount)
                    lTailIterator = 0;

                //if ( lTailIteratorOrig == atomic_cas( (volatile long*)&m_lTailIterator, lTailIterator, lTailIteratorOrig ))  
                if (std::atomic_compare_exchange_strong(&m_lTailIterator, &lTailIteratorOrig, lTailIterator))
                {
                    // Sets of sizeof(void*) are always atomic (you wont set a partial pointer).  
                    m_queue[lTailIteratorOrig] = NULL;

                    // Gets of sizeof(void*) are always atomic (you wont get a partial pointer).  
                    *ppdata = (_TyData*)pdata;

                    return true;
                }
            }
            else
            {
                bDone = true;
                m_lEventSet.clear();
            }
        }
        *ppdata = NULL;
        return false;
    }


    long countguess() const
    {
        long lCount = trycount();

        if (0 != lCount)
            return lCount;

        // If the queue is full then the item right before the tail item will be valid.  If it  
        // is empty then the item should be set to NULL.  
        long lLastInsert = m_lTailIterator - 1;
        if (lLastInsert < 0)
            lLastInsert = m_uiCount - 1;

        _TyData *pdata = m_queue[lLastInsert];
        if (pdata != NULL)
            return m_uiCount;

        return 0;
    }

    long getmaxsize() const
    {
        return m_uiCount;
    }

    bool HasItem()
    {
        return m_bHasItem.test_and_set();
    }

    void SetItemFlagBack()
    {
        m_bHasItem.clear();
    }

private:
    long trycount() const
    {
        long lHeadIterator = m_lHeadIterator;
        long lTailIterator = m_lTailIterator;

        if (lTailIterator > lHeadIterator)
            return m_uiCount - lTailIterator + lHeadIterator;

        // This has a bug where it returns 0 if the queue is full.  
        return lHeadIterator - lTailIterator;
    }

private:
    std::atomic<long> m_lHeadIterator;  // enqueue index  
    std::atomic<long> m_lTailIterator;  // dequeue index  
    _TyData **m_queue;                  // array of pointers to the data  
    long m_uiCount;                     // size of the array  
    std::atomic_flag m_lEventSet = ATOMIC_FLAG_INIT;       // a flag to use whether we should change the item flag  
    std::atomic_flag m_bHasItem = ATOMIC_FLAG_INIT;        // a flag to indicate whether there is an item enqueued  
};

#endif //INCLUDED_UTILS_LFRINGQUEUE  

　　

/*
* File:   main.cpp
* Author: Peng
*
* Created on February 22, 2014, 9:55 PM
*/
#include <iostream> 
#include <string>  
#include "freedeque.h" 
#include <sstream>  
#include <boost/thread/thread.hpp>  
#include <boost/lockfree/queue.hpp>    
#include <boost/atomic.hpp>  
#include<boost/thread/lock_guard.hpp>
#include<boost/thread/mutex.hpp>
#include<boost/date_time/posix_time/posix_time.hpp>

const int NUM_ENQUEUE_THREAD = 5;
const int NUM_DEQUEUE_THREAD = 10;
const long NUM_ITEM = 50000;
const long NUM_DATA = NUM_ENQUEUE_THREAD * NUM_ITEM;

class Data {
public:
	Data(int i = 0) : m_iData(i)
	{
		std::stringstream ss;
		ss << i;
		m_szDataString = ss.str();    
	}

	bool operator< (const Data & aData) const
	{
		if (m_iData < aData.m_iData)
			return true;
		else
			return false;
	}

	int& GetData()
	{
		return m_iData;
	}
private:
	int m_iData;
	std::string m_szDataString;
};

Data* g_arrData = new Data[NUM_DATA];
boost::mutex mtx;

constexpr long size = 0.5 * NUM_DATA;
lfringqueue < Data, 10000> LockFreeQueue;
boost::lockfree::queue<Data*> BoostQueue(10000);

bool GenerateRandomNumber_FindPointerToTheNumber_EnQueue(int n)
{
	for (long i = 0; i < NUM_ITEM; i++)
	{
		int x = i + NUM_ITEM * n;
		Data* pData = g_arrData + x;
		LockFreeQueue.enqueue(pData);	
	}
	return true;
}



void print(Data* pData) {
	if (!pData)
		return;

	boost::lock_guard<boost::mutex> lock(mtx);

	std::cout << pData->GetData() << std::endl;
	
}

bool Dequeue()
{
	Data *pData = NULL;
	
	while (true)
	{
		if (LockFreeQueue.dequeue(&pData) && pData)
		{
			print(pData);
		}
		else {
			boost::thread::sleep(boost::get_system_time() + boost::posix_time::milliseconds(5));
		}
	}

	return true;
}

int main(int argc, char** argv)
{
	for (int i = 0; i < NUM_DATA; ++i)
	{
		Data data(i);
		//DataArray[i] = data;
		*(g_arrData + i) = data;
	}

	std::thread PublishThread[NUM_ENQUEUE_THREAD];
	std::thread ConsumerThread[NUM_DEQUEUE_THREAD];
	std::chrono::duration<double> elapsed_seconds;

	for (int i = 0; i < NUM_ENQUEUE_THREAD; i++)
	{
		PublishThread[i] = std::thread(GenerateRandomNumber_FindPointerToTheNumber_EnQueue, i);
	}

	for (int i = 0; i < NUM_DEQUEUE_THREAD; i++)
	{
		ConsumerThread[i] = std::thread{ Dequeue };
	}

	for (int i = 0; i < NUM_DEQUEUE_THREAD; i++)
	{
		ConsumerThread[i].join();
	}

	for (int i = 0; i < NUM_ENQUEUE_THREAD; i++)
	{
		PublishThread[i].join();
	}

	delete[] g_arrData;
	return 0;
}

　　说明：模板文件是原作者写的，为了验证其正确性，后面的测试程序我改写了一下，最后测试程序是无法退出来的，这里只是测试，没有进一步完善了。

　　在测试中发现deque应该是大小限制的，再增大data的数据程序会阻塞在某个地方没有进一步再查找原因了，以后有时候再做修改，对于一般的工程都够用了。