用两个栈实现一个队列，并实现在多线程环境下

在知乎上看到这道题目，就实现了下看看。如有错误，麻烦各位看官留言指导下。

首先两个栈实现一个队列的思路是这样的：

      (1)用栈A作为队列的入口，只提供入队操作， 用栈B作为队列的出口，只提供出口。

      (2)由于栈的特性是后进先出， 队列是先进先出， 若要出队(即把栈A最底层的元素pop出来)， 需要把栈A整个转移到栈B(转移后就变为了倒序)，此时只要pop栈B就能成功出队一个元素

      (3)同理若要入队， 则要先把栈B整个转移到栈A，再push一个元素到栈A  ( 具体的操作只要简单画个图就能明白 )

具体见代码：

#pragma once
class Stack
{
public:
    Stack();
    ~Stack();

    bool isEmpty();
    void push(int value);
    int pop();
    int count();

private:
    int m_nTop;
    int m_nArray[400];

};

#include "Stack.h"
#include <string.h>

Stack::Stack()
{
    memset(m_nArray, sizeof(m_nArray), 0);
    m_nTop = -1;
}

Stack::~Stack()
{

}

bool Stack::isEmpty()
{
    return -1 == m_nTop;
}

void Stack::push(int value)
{
    m_nArray[++m_nTop] = value;
}

int Stack::pop()
{
    return m_nArray[m_nTop--];
}

int Stack::count()
{
    return m_nTop + 1;
}

#pragma once
#include "Stack.h"

//make a queue by using two stacks
class StackQueue 
{
public:
    StackQueue();
    ~StackQueue();

public:
    void push(int value);
    int pop(int thread_id);
    bool isEmpty();
    int count();

private:
    Stack m_InStack; //负责入队
    Stack m_OutStack; //负责出队
};

#include "StackQueue.h"
#include <iostream>

StackQueue::StackQueue()
{
}

StackQueue::~StackQueue()
{
}

bool StackQueue::isEmpty()
{
    return m_InStack.isEmpty() && m_OutStack.isEmpty();
}

int StackQueue::count()
{
    return m_InStack.count() + m_OutStack.count();
}

void StackQueue::push(int value)
{    
    if (!m_OutStack.isEmpty())
    {
        while(!m_OutStack.isEmpty())
        {
            int tmp = m_OutStack.pop();
            m_InStack.push(tmp);
        }
    }        
    m_InStack.push(value);
}

int StackQueue::pop(int thread_id)
{
    while(!m_InStack.isEmpty())
    {    
        int tmp = m_InStack.pop();
        m_OutStack.push(tmp);
    }
    if (!m_OutStack.isEmpty())
    {
        int tmp = m_OutStack.pop();
        std::cout << "pop queue! value=" << tmp << "  thread_id=" << thread_id << std::endl;
        return tmp;
    }
    else
    {
        std::cerr << " empty queue! pop failed! " << std::endl;
        return -1;
    }
}

相信各位看官看懂小弟的代码不成问题，然后就讲解下加入多线程环境要如何分析

      (1)由于栈A只作为入队，那么栈A入栈的时候需要锁住栈A

      (2)同理栈B只作为出队，那么栈B出栈的时候需要锁住栈B

      (3)当入队或出队时，可能会需要整个栈A转移到栈B(或栈B转移到栈A), 做转移时，需要同时锁住栈A和栈B。 注意：这里的转移操作的范围是整个栈的，直到其转移完成为止，都必须锁住栈A和栈B。

所以修改后的代码是这样的：

//头文件中定义栈A和栈B的互斥量
boost::recursive_mutex in_mtx;
boost::recursive_mutex out_mtx;

void StackQueue::push(int value)
{
    {    
        boost::recursive_mutex::scoped_lock out_lock(out_mtx); //对栈B的互斥量加锁
        if (!m_OutStack.isEmpty())
        {
            while(!m_OutStack.isEmpty())
            {
                int tmp = m_OutStack.pop();
                boost::recursive_mutex::scoped_lock in_lock(in_mtx);  //对栈A的互斥量加锁
                m_InStack.push(tmp);
            }
        }    
    }
    
    {
                //对栈A的互斥量加锁
        boost::recursive_mutex::scoped_lock in_lock(in_mtx); 
        m_InStack.push(value);
    }    
}

int StackQueue::pop(int thread_id)
{
    {
                //对栈A的互斥量加锁
        boost::recursive_mutex::scoped_lock in_lock(in_mtx);
        while(!m_InStack.isEmpty())
        {
            
            int tmp = m_InStack.pop();
            boost::recursive_mutex::scoped_lock out_lock(out_mtx); //对栈B的互斥量加锁
            m_OutStack.push(tmp);
        }
    }
    
    {
        boost::recursive_mutex::scoped_lock out_lock(out_mtx); //对栈B的互斥量加锁
        if (!m_OutStack.isEmpty())
        {
            int tmp = m_OutStack.pop();
            std::cout << "pop queue! value=" << tmp << "  thread_id=" << thread_id << std::endl;
            return tmp;
        }
        else
        {
            std::cerr << " empty queue! pop failed! " << std::endl;
            return -1;
        }
    }
}

       懒得去查资料就用了boost的互斥量和锁，其实也就是一样的东西。