boost 对于多线程应用的优化

多线程的应用开发，不管是客户端还是服务端都是能够极高提高性能的。如今CPU都是多核就更应该利用起来，但是不合理的代码会造成死锁宕机等，必须要注意以下几点：

1，多个子线程之间执行的逻辑最好是独立的，互不干涉的

2，子线程使用对象池创建销毁数据一定要加锁

3，子线程与主线程对同一数据尽量避免同时操作，如果不确定就需要加锁

4，线程之间的数据交互最好使用队列投递

现在我主要说的是跨线程队列，一般是使用加锁来保证队列数据正确，boost 增加了无锁队列，原理是使用原子操作队列交换，效率比使用锁的队列高很多

#pragma once
#pragma warning(disable:4996)

#include <boost/thread/mutex.hpp>
//#define USE_LIST

#ifndef USE_LIST
#include <queue>
template<class T>
class enable_queue : public std::queue<T>
{
public:
    void clear()
    {
        std::queue<T>::c.clear();
    }

    bool pop(T& v)
    {
        v = std::queue<T>::front();
        std::queue<T>::pop();
        return true;
    }
};

template<class T>
class enable_safe_queue : public std::queue<T>
{
public:
    void clear()
    {
        std::queue<T>::c.clear();
    }

    bool pop(T& v)
    {
        v = std::queue<T>::front();
        std::queue<T>::pop();
        return true;
    }

    void safe_pop(T& v)
    {
        boost::lock_guard<boost::mutex> lock(m_mutex);
        this->pop(v);
    }

    void safe_push(T& v)
    {
        boost::lock_guard<boost::mutex> lock(m_mutex);
        std::queue<T>::push(v);
    }

    void safe_swap(enable_queue<T> q)
    {
        boost::lock_guard<boost::mutex> lock(m_mutex);
        swap(q);
    }

private:
    boost::mutex m_mutex;
};

#else
#include <list>

template<class T>
class enable_queue : public std::list<T>
{
public:    
    bool pop(T& v)
    {
        v = front();
        erase(begin());
        return true;
    }

    void push(T& v)
    {
        push_back(v);
    }
};

template<class T>
class enable_safe_queue : public std::queue<T>
{
public:
    bool pop(T& v)
    {
        v = front();
        erase(begin());
        return true;
    }

    void push(T& v)
    {
        push_back(v);
    }

    void safe_pop(T& v)
    {
        boost::lock_guard<boost::mutex> lock(m_mutex);
        pop(v);
    }

    void safe_push(T& v)
    {
        boost::lock_guard<boost::mutex> lock(m_mutex);
        push(v);
    }

    void safe_swap(enable_safe_queue<T> q)
    {
        boost::lock_guard<boost::mutex> lock(m_mutex);
        swap(q);
    }
private:
    boost::mutex m_mutex;
};

#endif



#include <boost/lockfree/queue.hpp> 
#include <boost/lockfree/spsc_queue.hpp> 
#include <boost/atomic.hpp>
//无锁线程安全队列

template<class T>
class fast_safe_queue : public boost::lockfree::spsc_queue<T>
{
public:
    //queue必须先定义队列数量 过大会初始化很慢
    fast_safe_queue(uint16_t maxqueue = std::numeric_limits<uint16_t>::max())
        :boost::lockfree::spsc_queue<T>(maxqueue)
    {

    }
    ~fast_safe_queue()
    {
        //clear();
    }


    //必须在停止使用后调用 否则无法完全清理掉
    void clear()
    {
        T temp;
        while(!boost::lockfree::spsc_queue<T>::empty())
        {
            if(!boost::lockfree::spsc_queue<T>::pop(temp))
                break;
        }
    }
};

template<class T>
class fast_count_queue : public boost::lockfree::spsc_queue<T>
{
public:
    //queue必须先定义队列数量 过大会初始化很慢
    fast_count_queue(uint16_t maxqueue = std::numeric_limits<uint16_t>::max())
        :boost::lockfree::spsc_queue<T>(maxqueue),m_count(0)
    {

    }
    ~fast_count_queue()
    {
        //clear();
    }

    //必须在停止使用后调用 否则无法完全清理掉
    void clear()
    {
        T temp;
        while(!boost::lockfree::spsc_queue<T>::empty())
        {
            if(!safe_pop(temp))
                break;
        }
    }

    bool safe_pop(T& v)
    {
        if(boost::lockfree::spsc_queue<T>::pop(v))
        {
            m_count--;
            return true;
        }
        return false;
    }

    bool safe_push(const T& v)
    {
        if(boost::lockfree::spsc_queue<T>::push(v))
        {
            m_count++;
            return true;
        }
        return false;
    }

    int size()
    {
        return m_count;
    }

private:
    boost::atomic_int m_count; 
};

//释放资源时可能出问题
template<class T>
class fast_mutli_queue : public boost::lockfree::queue<T>
{
public:
    //queue必须先定义队列数量 过大会初始化很慢
    fast_mutli_queue(uint16_t maxqueue = std::numeric_limits<uint16_t>::max())
        :boost::lockfree::queue<T>(maxqueue)
    {

    }
    ~fast_mutli_queue()
    {
        //clear();
    }


    //必须在停止使用后调用 否则无法完全清理掉
    void clear()
    {
        T temp;
        while(!boost::lockfree::queue<T>::empty())
        {
            if(!boost::lockfree::queue<T>::pop(temp))
                break;
        }
    }
};

对于boost的线程池推荐使用threadpool，可以自己在网上找到源代码，需要少量修改，注意在退出时有个线程未退出导致的内存泄露的BUG