多任务编程超入门-多任务安全的数据类

问题的提出

这几天一直在折腾的数据交换的例子中，我们使用互斥量来保证线程间数据交换的完整性。不难看出，要保证数据交换的正常进行，需要使用数据类的程序的设计者理解线程间数据交换的机制。

C++的第一个特性就是封装，封装通过分离接口和实现，除了降低模块之间耦合性以外，还可以使功能的利用者在不了解功能实现细节的情况使用该功能。

本文就利用这个特性将多线程数据保护功能封装在数据类中，以实现多任务安全的数据类。

代码

首先来看头文件，唯一明显的不同是，增加了QMultex成员和相应的头文件。

#ifndef DATAARRAY_H
#define DATAARRAY_H

#include

#define ARRAY_SIZE  500

class DataArray
{
protected:
    int m_buffer[ARRAY_SIZE];
    int m_dataSize;
    QMutex m_mutex;
public:
    DataArray();
    int getDataSize();
    int getData(int index);
    int addData(int data);
    void clearData();
    int setData(int* buffer, int data_size);
    int removeData(int* buffer,
                   int buffer_size);
};

#endif // DATAARRAY_H

再看CPP。

#include "dataarray.h"

DataArray::DataArray()
    :m_dataSize(0)
    ,m_mutex(QMutex::Recursive)
{
}

int DataArray::getDataSize()
{
    m_mutex.lock();
    int size = 0;
    size = m_dataSize;
    m_mutex.unlock();
    return size;
}

int DataArray::getData(int index)
{
   m_mutex.lock();
   int result = -1;
   if(index >= 0 && index < m_dataSize)
   {
        int data = m_buffer[index];
        result = data;
   }
   m_mutex.unlock();
   return result;
}

int DataArray::addData(int data)
{
    m_mutex.lock();
    if(m_dataSize < (ARRAY_SIZE - 1))
    {
        m_buffer[m_dataSize] = data;
        m_dataSize++;
    }
    m_mutex.unlock();
    return true;
}

void DataArray::clearData()
{
    m_mutex.lock();
    m_dataSize = 0;
    m_mutex.unlock();
}

int DataArray::setData(int* buffer, 
                       int data_size)
{
    m_mutex.lock();
    int set_count = 0;
    if(getDataSize() == 0)
    {
        for(int i = 0; i < data_size; i++)
        {
            addData(buffer[i]);
        }
        set_count = data_size;
    }
    m_mutex.unlock();
    return set_count;
}

int DataArray::removeData(int* buffer,
                          int buffer_size)
{
    m_mutex.lock();
    int remove_count = 0;
    int data_size = getDataSize();
    if(buffer_size >= data_size)
    {
        for(int i = 0; i < data_size; i++)
        {
            buffer[i] = getData(i);
        }
        clearData();
        remove_count = data_size;
    }
    m_mutex.unlock(); 
    return remove_count;
}

代 码略长，但应该很好理解，这里为了实现多任务安全做的事情很简单：在每个成员函数的最开始调用m_mutex.lock();在函数返回之前调用 m_mutex.unlock()。这样做就可以保证数据操作的代码不会被途中打断。所有的一切都在类的内部实现，不用利用者操心。

递归互斥量

不 知道你注意了没有，最后的两个成员函数：setData和removeData是新增加的，在调用了m_mutex.lock()之后，又调用了其他成员 函数（例如getDataSize）。在这些成员函数中还会再次调用m_mutex.lock()，如果按照一般的逻辑来说，第二次调用应该不会成功。如果没有特别的方法的话，恐怕就要通过调整代码结构来解决了。

这 里请你回头看构造函数，在初始化QMutex时，使用了QMutex::Recursive参数。使用这个参数值初始化QMutex以后，在同一个线程中 重复调用lock方法时总会成功，不同线程调用lock方法则遵循一般的原则。这样就用最简单的方式解决了互斥量加锁嵌套的问题，就像什么都没有发生一 样。

当然，lock/unlock的配对执行总是必须的。

写在文章的最后

既然已经读到这里了，拜托大家再用一分钟时间，将文章转发到各位的朋友圈，微信群中。