用C++实现数据总线的方法系列(中)：数据总线的实现

用C++实现数据总线的方法系列(中)：数据总线的实现

原文: link.
数据总线以及传输的数据的定义和实现

传输数据类Data，它是由数据的地址和数据的大小两个成员组成的。

数据总线类DataQueue，需要有存放总线数据的数据链表，构成锁的互斥量和用于多线程同步的条件变量，同时也需要具有最基本的Push和Pop函数，还有就是Clear和Empty函数。

#ifndef DATA_QUEUE_H
#define DATA_QUEUE_H

#include<stdint.h>
#include<mutex>
#include<condition_variable>
#include<list>

class Data
{
public:
    Data(): m_address(NULL), m_size(0)
    {


    }

    Data(uint64_t size): m_size(size)
    {
        m_address = new char[m_size];
    }

    ~Data()
    {
        if (m_address != NULL)
        {
            delete[] m_address;
            m_address = NULL;
        }
    }

    char* m_address;
    uint64_t m_size;
};
class DataQueue
{
public:
    static void Clear();
    static bool Empty();

    static void Push(Data* dataPtr);
    static void Push(void* data, uint64_t size);
    static Data* Pop();
private:
    static std::mutex               s_mt;
    static std::condition_variable  s_cv;
    static std::list<Data *>        s_queue;
};
#endif

#include "DataQueue.h"

static int POP_TIMEOUT = 1000;

std::mutex              DataQueue::s_mt;
std::condition_variable DataQueue::s_cv;
std::list<Data *>       DataQueue::s_queue;
void DataQueue::Clear()
{
    std::list<Data *>::iterator it = s_queue.begin();
    for (; it != s_queue.end(); ++it)
    {
        delete *it;
    }
    s_queue.clear();
}
bool DataQueue::Empty()
{
    std::unique_lock<std::mutex> lock(s_mt);
    return s_queue.empty();
}

void DataQueue::Push(Data* dataPtr)
{
    std::unique_lock<std::mutex> lock(s_mt);
    s_queue.push_back(dataPtr);
    s_cv.notify_all();
}
void DataQueue::Push(void* data, uint64_t size)
{
    Data *dataPtr = new Data(size);
    memcpy(dataPtr->m_address, data, size);
    Push(dataPtr);
}

Data* DataQueue::Pop()
{
    Data* dataPtr = NULL;
    {
        std::unique_lock<std::mutex> lock(s_mt);
        while (s_queue.empty())
        {
            if (s_cv.wait_for(lock, std::chrono::milliseconds(POP_TIMEOUT)) == std::cv_status::timeout)
            {
                break;
            }
        }

        if (!s_queue.empty())
        {
            dataPtr = s_queue.front();
            s_queue.pop_front();
        }
    }
    
    return dataPtr;

}

这个示例所实现的数据总线呢，虽然可以传递任意类型的数据，但是为了提高效率，所以我们传递的实际上是原始数据的地址，这样减少了数据的构造和拷贝，确实提高了效率，但在使用的过程中就需要留意使用方法，以免造成程序异常。

读取数据会出错的情况
传输的数据类User，它是由id和info两个数据局成员来组成的。同时我们定义了UserPtr作为User类的shared_ptr智能指针。

#ifndef USER_H
#define USER_H

#include<string>
#include<memory>
class User
{
public:
    User(int id, std::string info):m_id(id), m_info(info) {}

    int ID()
    {
        return m_id;
    }

    std::string Info()
    {
        return m_info;
    }
private:
    int m_id;
    std::string m_info;
};

using UserPtr = std::shared_ptr<User>;

调用程序，在SetData线程函数中，我们新建了一个原始数据User对象，并用一个shared_ptr智能指针pUser指向它，然后我们用了一个变量addr存放了这个User对象的地址，然后将addr里的值，也就是User对象的地址放入拷贝到传输数据对象data中，存放到数据总线中。
在GetData线程函数中，获得了传输的数据对象data，然后得到了data里面的值，也就是原始数据User对象的地址，然后使用reinterpret_cast将这个地址值强转为一个目标数据User对象，因为原始对象和目标对象的结构一致，所以也就得到了原始数据值。

#include "stdafx.h"
#include "User.h"
#include "DataQueue.h"
#include<atomic>
#include<thread>
#include<string>
#include<iostream>
static std::atomic_bool getStop = false;

void SetData()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
    int i = 1;
    while (i <= 1) //insert one data
    {   
        UserPtr pUser(new User(i, std::to_string(i * 10)));
        User* user = pUser.get();
        uint64_t addr = (uint64_t)user;
        DataQueue::Push(&addr, sizeof(addr));
        i++;
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}


void GetData()
{
    while (true)
    {
        Data *data = DataQueue::Pop();
        if (data != NULL)
        {
            uint64_t addr = 0;
            memcpy(&addr, data->m_address, sizeof(addr));
            UserPtr pUser(reinterpret_cast<User*>(addr));
            User* user = pUser.get();
            std::cout << "---user id: " << user->ID() << "---user info: " << user->Info().c_str() << std::endl;


            //std::cout << "---user id: " << pUser->ID() << "---user info: " << pUser->Info().c_str() << std::endl;
        }


    }
}
int main()
{
    std::thread thGet(GetData);
    std::thread thSet(SetData);


    thGet.join();
    thSet.join();
    return 0;
}

但是报错了，而且是个内存错误，原因是为了提高效率，我们在数据总线上传输的是原始数据的地址，但是，因为在SetData新建的原始数据User使用的是shared_ptr智能指针来指向它，在Push函数放入原始数据地址后，shared_ptr智能指针这个局部变量也将释放，这样原始数据的引用计数就归零了，所以原始数据就被释放了，导致读取线程在总线Pop数据时崩溃。

正确的数据总线的使用方法
正确的使用方法是：使用boost::intrusive_ptr智能指针，同时需要用总线的数据类自己来实现引用计数，这样就可以保证原始数据不被释放，具体方法如下：

建立一个提供引用计数功能的基类ReferenceCounter，这个基类需要提供intrusive_ptr_add_ref和intrusive_ptr_release两个接口供boost::intrusive_ptr来进行引用计数的增加和减少。同时，要提供两个接口来供我们自己来进行进行引用计数的增加和减少，这里我们实现了IncReference和DecReference这两个接口来完成相应的功能

#ifndef ADVANCED_USER_H
#define ADVANCED_USER_H
#include <assert.h>
#include <atomic>
#include <string>
#include <boost/intrusive_ptr.hpp>

class ReferenceCounter
{
public:
    friend void intrusive_ptr_add_ref(ReferenceCounter *p)
    {
        assert(p);
        assert(p->ref_count >= 0);
        ++p->ref_count;
    }

    friend void intrusive_ptr_release(ReferenceCounter *p)
    {
        assert(p);
        assert(p->ref_count > 0);
        if (--p->ref_count == 0)
        {
            delete p;
        }
    }
    friend uint64_t IncReference(ReferenceCounter *p)
    {
        intrusive_ptr_add_ref(p);
        return reinterpret_cast<uint64_t>(p);
    }

    friend void DecReference(ReferenceCounter *p)
    {
        intrusive_ptr_release(p);
    }

    int RefCount()
    {
        return ref_count;
    }
protected:
    ReferenceCounter() { ref_count = 0; }
    virtual ~ReferenceCounter() {};

private:
    std::atomic_int ref_count;
};

class AdvancedUser: public ReferenceCounter
{
public:
    AdvancedUser(int id, std::string info) :m_id(id), m_info(info) {}

    int ID()
    {
        return m_id;
    }

    std::string Info()
    {
        return m_info;
    }
private:
    int m_id;
    std::string m_info;
};

using AdvancedUserPtr = boost::intrusive_ptr<AdvancedUser>;
#endif

如果调用总线的方式不改变，还是会报错，因为其实和之前使用shared_ptr没有本质的区别，还是会因为数据释放问题而报错，只不过我们能更清楚的了解数据释放的过程。

#include "stdafx.h"
#include "User.h"
#include "AdvancedUser.h"
#include "DataQueue.h"
#include<atomic>
#include<thread>
#include<string>
#include<iostream>

void SetData()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
    int i = 1;
    while (i <= 1) 
    {
        AdvancedUserPtr pUser(new AdvancedUser(i, std::to_string(i * 10)));
        AdvancedUser*  user = pUser.get();
        uint64_t addr = (uint64_t)user;
        DataQueue::Push(&addr, sizeof(addr));
        i++;
    }
    std::cout << "---SetData End！" << std::endl;
}

void GetData()
{
    while (true)
    {
        std::this_thread::sleep_for(std::chrono::seconds(5));
        Data *data = DataQueue::Pop();
        if (data != NULL)
        {
            uint64_t addr = 0;
            memcpy(&addr, data->m_address, sizeof(data->m_size));
            AdvancedUserPtr pUser(reinterpret_cast<AdvancedUser*>(addr));
            std::cout << "---user id: " << pUser->ID() << "---user info: " << pUser->Info().c_str() << std::endl;
        }
    }
    std::cout << "---GetData End！" << std::endl;
}


int main()
{
    std::thread thGet(GetData);
    std::thread thSet(SetData);

    thGet.join();
    thSet.join();
    return 0;
}