多线程环境下队列操作之锁的教训

　　之前一直在研究多线程环境下的编程方法，却很少实战体验，以至于我一提到多线程编程，我总是信心不足，又总是说不出到底哪里不明白。今天工程现场反馈了一个“老问题”，我一直担心的是DAServer的运行机制有什么我不明白的地方，DAS Toolkit中总有一部分是我没有仔细研究的，在我心中有阴影，所以工程出了问题我第一反应就是“会不会问题出在阴影里？”。结果，至今为止，我总结起来问题90%都是在自己编码部分。

　　我的DAServer中有一个需求，就是上送某个定点数据的速度不能太快，否则后台接收不过来。于是，我设计了一个类，包含了两条队列，其中一条队列是需要上送的数据，另一条队列是历史上曾经更新过的点记录及上送时间。每次组装报文时需要检查队列中是否有某个点，以及该点是否在1.5秒内“曾经上送过”。如果上送过就等下次再来检查，如果没有上送过则上送此信息并记录一下上送时间。

　　我在设计这个类时一直在关注逻辑，却忽略了这是一个多线程环境的应用——装入队列数据的线程和取出队列数据的线程是不同的。好吧，只能说明我们的应用场景太低端，多线程争用资源的场景不是太频繁，以至于我过了这么久才明白过来。这个类的设计代码如下：

struct SUpdateValue
{
    int m_dataID;            // 数据点号
    DASVariant m_dataValue;    // 数据值
    SUpdateValue* next;

    SUpdateValue() : m_dataID(0), next(NULL){ }
    SUpdateValue(int id, DASVariant& val) : m_dataID(id), m_dataValue(val), next(NULL){    }
};

struct SUpdateTime
{
    int dataID;            // 数据点号
    long lastSendTime;    // 上次上送缓冲数据的时间戳（毫秒）
    SUpdateTime* next;

    SUpdateTime() : dataID(0), lastSendTime(0), next(NULL){}
};

class CDelayQueue
{
public:
    CDelayQueue();
    ~CDelayQueue();
    bool EnqueFrame(int dataID, DASVariant& dataValue);        // 向延迟队列中装入新数据
    bool DequeFrame(int dataID, DASVariant& dataValue);        // 从延迟队列中取出指定的数据
    void DelayUpdateTime(int dataID);    // 设定数据点的更新时间戳，一般用于防止过快上送
    int GetFrameCount(void);            // 获取延迟队列中的对象个数
    string GetFrameList(void);            // 获取对象名称列表，以逗号分隔

protected:
    bool AskForUpdate(int dataID);        // 申请上送新数据

private:
    SUpdateValue* m_pHead;        // 需要延迟发送的数据队列
    SUpdateValue* m_pTail;
    SUpdateTime* m_pTimeHead;    // 已经发送的数据队列的历史记录（超时后失去记录）
};

　　实现部分如下：

CDelayQueue::CDelayQueue() : m_pHead(NULL), m_pTail(NULL), m_pTimeHead(NULL)
{
}

CDelayQueue::~CDelayQueue()
{
    while (NULL != m_pHead)
    {
        SUpdateValue* p = m_pHead;
        m_pHead = m_pHead->next;
        delete p;
    }

    while (NULL != m_pTimeHead)
    {
        SUpdateTime* p = m_pTimeHead;
        m_pTimeHead = m_pTimeHead->next;
        delete p;
    }
}

bool CDelayQueue::EnqueFrame(int dataID, DASVariant& dataValue)
{
    SUpdateValue* pNew = new SUpdateValue(dataID, dataValue);
    if (NULL == pNew)
    {
        return false;
    }

    if (NULL == m_pHead)
    {
        m_pHead = m_pTail = pNew;
    }
    else
    {
        m_pTail->next = pNew;
        m_pTail = m_pTail->next;
    }

    return true;
}

bool CDelayQueue::DequeFrame(int dataID, DASVariant& dataValue)
{
    if (NULL == m_pHead)
    {
        return false;
    }

    // 检查队列中是否存在该点
    if (m_pHead->m_dataID == dataID)
    {
        if (AskForUpdate(dataID))
        {
            dataValue = m_pHead->m_dataValue;
            SUpdateValue* pDel = m_pHead;
            m_pHead = m_pHead->next;
            delete pDel;
            return true;
        }
        return false;
    }
    
    SUpdateValue* pPre = m_pHead;
    SUpdateValue* pValue = m_pHead->next;
    while (pValue != NULL)
    {
        if (pValue->m_dataID == dataID)
        {
            if (AskForUpdate(pValue->m_dataID))
            {
                dataValue = pValue->m_dataValue;
                pPre->next = pValue->next;
                delete pValue;
                return true;
            }
            return false;
        }
        pPre = pValue;
        pValue = pPre->next;
    }

    return false;
}

bool CDelayQueue::AskForUpdate(int dataID)
{
    long curTime = GetTickCount();

    // 检查是否在短时间内更新过该数据点
    SUpdateTime* pList = m_pTimeHead;
    while (pList)
    {
        if (pList->dataID == dataID)
        {
            if ((curTime - pList->lastSendTime) < 1500)        // xiaoku
            {
                return false;
            }
            pList->lastSendTime = curTime;
            return true;
        }
        pList = pList->next;
    }

    // 如果记录中没有目标点，则创建历史记录
    if (NULL == pList)
    {
        pList = new SUpdateTime();
        pList->dataID = dataID;
        pList->lastSendTime = curTime;
        pList->next = m_pTimeHead;
        m_pTimeHead = pList;
    }

    return true;
}

void CDelayQueue::DelayUpdateTime(int dataID)
{
    long curTime = ::GetTickCount();
    SUpdateTime* pList = m_pTimeHead;
    while (pList)
    {
        if (pList->dataID == dataID)
        {
            pList->lastSendTime = curTime - 500;
            return ;
        }
        pList = pList->next;
    }

    // 如果记录中没有目标点，则创建历史记录
    if (NULL == pList)
    {
        pList = new SUpdateTime();
        pList->dataID = dataID;
        pList->lastSendTime = curTime - 500;
        pList->next = m_pTimeHead;
        m_pTimeHead = pList;
    }
}

int CDelayQueue::GetFrameCount()
{
    if (NULL == m_pHead)
    {
        return 0;
    }

    int count = 1;
    SUpdateValue* p = m_pHead;
    while(p != m_pTail)
    {
        ++count;
        p = p->next;
    }
    return count;
}

string CDelayQueue::GetFrameList()
{
    string strNameList("");
    if (NULL == m_pHead)
    {
        return strNameList;
    }
    SUpdateValue* p = m_pHead;
    char szData[16];
    sprintf_s(szData, 16, "%d", p->m_dataID);
    strNameList += szData;
    while(p != m_pTail)
    {
        sprintf_s(szData, 16, "%d", p->next->m_dataID);
        strNameList += ";";
        strNameList += szData;
        p = p->next;
    }

    return strNameList;
}

　　最关键两个接口是EnqueFrame() 和 DequeFrame() ，分别是装入队列和从队列中取数。都是在操作队列，如果是不同的线程，怎么能不考虑线程互斥的问题呢？好吧，迅速引入LockerGuard。

　　这个失败的例子放在这里警示一下自己！