问题的提出
这几天一直在折腾的数据交换的例子中，我们使用互斥量来保证线程间数据交换的完整性。不难看出，要保证数据交换的正常进行，需要使用数据类的程序的设计者理解线程间数据交换的机制。
C++的第一个特性就是封装，封装通过分离接口和实现，除了降低模块之间耦合性以外，还可以使功能的利用者在不了解功能实现细节的情况使用该功能。
利用这个特性将多线程数据保护功能封装在数据类中，以实现多任务安全的数据类。
代码
首先来看头文件，唯一明显的不同是，增加了QMultex成员和相应的头文件。
#ifndef DATAARRAY_H
#define DATAARRAY_H
#include <qmutex.h>
#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的配对执行总是必须的。
