数据结构与算法(c++)—

“双缓存队列”是我在一次开发任务中针对特殊场景设计出来的结构。使用场景为：发送端持续向接收端发送数据包——并且不理会接收端是否完成业务逻辑。由于接收端在任何情况下停止响应即可能产生数据丢失，因此无法简单的设计一条线程安全队列来对数据写入或读取（读取数据时将队列上锁视为对写入的停止响应）。

鉴于此，我的设计思路如下：

接收端首先向A队列中写入数据，然后当数据处理请求到来的时候切换到B队列继续写入，之后将A队列中的数据交给数据处理模块，处理完成以后A队列数据清空。当下一次数据处理请求到来时，再将写入请求切换回A队列，并把B队列中的数据提交给数据处理模块再清空队列B，轮流作业。

有了思路以后，代码就比较简单了。

#include <list>

template<typename T>
class DoubleArray {

    struct NODE {
        T t;
        NODE* next;
    };
    int size_a;
    int size_b;
    NODE* header_a;
    NODE* header_a_cur;
    NODE* header_b;
    NODE* header_b_cur;
    int trigger;
public:

    DoubleArray() : size_a(0), size_b(0), trigger(0), header_a(0), header_a_cur(0), header_b(0), header_b_cur(0) {
    }

    int push(T t);
    std::list<T>& fetch(std::list<T>& list);
};

template<typename T>
int DoubleArray<T>::push(T t) {
    NODE *n = new NODE;
    n->t = t;
    n->next = 0;
    if (size_a == 0 && trigger == 0) {
        header_a = n;
        header_a_cur = n;
        size_a++;
    } else if (size_b == 0 && trigger == 1) {
        header_b = n;
        header_b_cur = n;
        size_b++;
    } else {
        switch (trigger) {
            case 0:
                header_a_cur->next = n;
                header_a_cur = n;
                size_a++;
                break;
            case 1:
                header_b_cur->next = n;
                header_b_cur = n;
                size_b++;
                break;
        }
    }
}

template<typename T>
std::list<T>& DoubleArray<T>::fetch(std::list<T>& list) {
    switch (trigger) {
        case 0:
            if (header_a != 0) {
                // change b
                trigger = 1;
                // fetch a
                NODE* temp = header_a;
                while (temp) {
                    list.push_back(temp->t);
                    temp = temp->next;
                }
                // delete a
                temp = header_a;
                for (int i = 0; i < size_a; ++i) {
                    NODE* p = temp;
                    temp = temp->next;
                    delete p;
                }
                size_a = 0;
                header_a = 0;
                header_a_cur = 0;
            }
            break;
        case 1:
            if (header_b != 0) {
                // change a
                trigger = 0;
                // fetch b
                NODE* temp = header_b;
                // delete b
                while (temp) {
                    list.push_back(temp->t);
                    temp = temp->next;
                }
                temp = header_b;
                for (int i = 0; i < size_b; ++i) {
                    NODE* p = temp;
                    temp = temp->next;
                    delete p;
                }
                size_b = 0;
                header_b = 0;
                header_b_cur = 0;
            }
            break;
    }
    return list;
}

注1：开发环境与IDE分别为CentOS 7，NetBeans 8.2

数据结构与算法(c++)——双缓存队列

推荐阅读