C++调整库以实现多线程

Question

我正在使用libconfig ++和线程来制作小型服务器应用程序。问题的关键是，libconfig++ is not thread safe，所以我的想法是创建另一个类，用作与互斥的包装，像这样的东西：

class app_config { 
public: 
    app_config(); 
    /* Here be my problems. */ 
    void set(); 
    void get(); 
    virtual ~app_config(); 

private: 
    Config cfg; 
    boost::mutex *cfg_mutex; 
}; 

现在，这是所有的好，直到我意识到libconfig supports plenty of types其变量。而那时候，我们的主角（我）发现自己正在寻找任何C++大师，并以一种善意的心态向他展示如何实现这一目标。

实质上，get和set功能将需要含有在set“路径到配置文件的变量（I不会介意使用任一）和返回类型（或者第二个参数中std::string或char*path可变s）的情况应该有所不同...

一如既往，任何帮助将不胜感激。

朱利安

Answer 1

你可以使用这种方法。我认为这更难以被误用，因此更胜一筹。 Libconfig实例是包装器中的私有成员，不能在没有锁的情况下访问。

#include <boost/thread/mutex.hpp> 
#include <boost/thread/locks.hpp> 
#include <boost/shared_ptr.hpp> 

class Libconfig { 
public: 
    int Get(const char*) { return 0; } 
}; 

class LibConfLock; 

class LibconfMultithreadingWrapper { 
    friend class LibConfLock; 
public: 
    LibconfMultithreadingWrapper() 
     :m_Libconfig(new Libconfig()) 
     ,m_Mutex(new boost::mutex()) 
    {} 

private: 
    boost::shared_ptr<Libconfig> m_Libconfig; 
    boost::shared_ptr<boost::mutex> m_Mutex; 
}; 

class LibConfLock { 
public: 
    LibConfLock(const LibconfMultithreadingWrapper& wrapper) 
     :m_Libconfig(wrapper.m_Libconfig) 
     ,m_Mutex(wrapper.m_Mutex) 
     ,m_Lock(new LockType(*m_Mutex)) 
    {} 
    Libconfig& GetLibconf() const { return *m_Libconfig; } 
private: 
    typedef boost::lock_guard<boost::mutex> LockType; 
    boost::shared_ptr<Libconfig> m_Libconfig; 
    boost::shared_ptr<boost::mutex> m_Mutex; 
    boost::shared_ptr<LockType> m_Lock; 
}; 

int main() { 
    LibconfMultithreadingWrapper wrapper; 
    int i = LibConfLock(wrapper).GetLibconf().Get("hallo"); 

    return i; 
} 

Answer 2

你可以写转发所有的函数调用私人libconfig实例的装饰类。这意味着你需要添加你想用于装饰器的所有功能。 另一种可能性是将调用转发给libconfig以实现实际锁定的类。

#include <boost/thread/mutex.hpp> 
#include <boost/thread/locks.hpp> 
#include <boost/bind.hpp> 

class MultithreadingWrapper { 
public: 
    template <class V, class T> 
    V ExecuteThreadSaveWithReturn(T func) { 
     boost::lock_guard<boost::mutex> l(m_Mutex); 
     return func(); 
    } 

    template <class T> 
    void ExecuteThreadSave(T func) { 
     boost::lock_guard<boost::mutex> l(m_Mutex); 
     func(); 
    } 

private: 
    boost::mutex m_Mutex; 
}; 

void f() {} 
void f(int) { } 
int f(int, int) { return 0; } 

int main() { 
    MultithreadingWrapper wrapper; 
    wrapper.ExecuteThreadSave(boost::bind(f)); 
    wrapper.ExecuteThreadSave(boost::bind(f, 1)); 
    int i = wrapper.ExecuteThreadSaveWithReturn<int>(boost::bind(f, 1, 1)); 
    return i; 
}