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

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

假设有一个类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，看起来是不是相对优雅得体些了？