优雅的让一个类在线程安全和线程非安全间切换

一个良好的多线程库，不应当一刀切的全加锁。因为有些时候，虽然是多线程环境，但可能依照设计一个类只会被一个线程操作，这个时候加锁是多余的，纯浪费性能，但另一些场景又需要它是线程安全的。

假设有一个类X：
class X
{
public:
void xoo();
};

这里总结几个常见的做法：
1.本身不加锁，由调用者来加锁，坏处是如果多数场景都是加锁的，由会产生重复代码
class Z
{
public:
void zoo()
{
LockHelper<CLock> lh(_lock); // 调用者Z来加锁
_x.xoo();
};

private:
CLock _lock;
X _x;
};

2.类的实现中，加if判断
class X
{
public:
X(bool is_threadsafe)
:_is_threadsafe(is_threadsafe)
{
}

void xoo()
{
if (_is_threadsafe)
{
// 根据条件加锁
_lock.lock();
}

。。。。。。

if (_is_threadsafe)
{
_lock.unlock();
}
}

private:
bool _is_threadsafe;
CLock _lock;
};

3.分成两个类，第一个类是无锁的，第二个类通过聚合第一个类，并用锁包装一下
class RawX
{
public:
void xoo()
{
// RawX总是不加锁
}
};

class SafeX
{
public:
void xoo()
{
LockHelper<CLock> lh(_lock); // 总是加锁
_raw_x.xoo();
}

private:
CLock _lock;
RawX _raw_x;
};

下面提出一种在mooon中使用的相对更优雅的方法，引用一个空锁类CNullLock，它仅提供锁的接口，加锁和解锁函数体都是空的：
class CNullLock
{
public:
void lock()
{
}

void unlock()
{
}
};

接下来看新的X的实现，需要将它变成一个模板类：
template <class Lock>
class X
{
public:
void xoo()
{
LockHelper<CLock> lh(_lock); // 这里并不一定真是加锁
}
};

如果需要X是线程安全的，可以这样使用：
X<CLock> x;
如果不需要X是线程安全的，则可以如下使用：
X<CNullLock> x;

这样的一个X，看起来是不是相对优雅得体些了？