c++ - C++中互斥锁的单例类

Question

我正在努力让它工作，但似乎有一些我不完全理解的东西。

我在单个文件中有一个多线程应用程序(2 个类和真正的主程序，我在其中创建线程和所有内容)。我想分成 3 个文件。一个用于每个类(带有它们的标题)，一个用于 main。

我有几个 mutices 和一个队列来在线程之间共享消息并随时锁定和解锁它们。

我想写一个单例类，这样所有类都可以共享互斥量:

标题:

#ifndef COMMONSINGLETON_H
#define COMMONSINGLETON_H

#include <mutex>          // std::mutex
#include <queue>

class CommonSingleton{
    private:
        static std::mutex               mutex_w_b;
        //static std::mutex               mutex_wifi_ok;
        //static std::queue <std::string> queue_w_b;

    public:
        static CommonSingleton& getInstance();
        std::mutex GetMutexWB();
        //std::mutex GetMutexWiFiOk();
        //std::queue <std::string> GetQueueWB();
    private:
        CommonSingleton() {};
        CommonSingleton(CommonSingleton const&);
        void operator=(CommonSingleton const&);
};
#endif

还有我的 .cpp 文件:

#include "commonsingleton.h"

static CommonSingleton& CommonSingleton::getInstance(){
    static CommonSingleton instance;
    return instance;
}
std::mutex CommonSingleton::GetMutexWB(){
    return mutex_w_b;
}
/*std::mutex CommonSingleton::GetMutexWiFiOk(){
    return mutex_wifi_ok;
}
std::queue <std::string> CommonSingleton::GetQueueWB(){
   return queue_w_b;
}*/

在我的主要我有这个来测试互斥锁:

CommonSingleton::getInstance().GetMutexWB.lock();

不过现在评论出来了，就是为了搞清楚怎么编译。这是我得到的错误:

commonsingleton.cpp:4:54: error: cannot declare member function ‘static 
CommonSingleton& CommonSingleton::getInstance()’ to have static linkage [-
fpermissive]
static CommonSingleton& CommonSingleton::getInstance(){
                                                  ^
commonsingleton.cpp: In member function ‘std::mutex 
CommonSingleton::GetMutexWB()’:
commonsingleton.cpp:9:12: error: use of deleted function 
‘std::mutex::mutex(const std::mutex&)’
return mutex_w_b;
            ^
In file included from commonsingleton.h:5:0,
from commonsingleton.cpp:1:
/usr/include/c++/4.8/mutex:128:5: error: declared here
mutex(const mutex&) = delete;

我在这里做错了什么？

Answer 1

您不需要那么多样板文件。你只需要一个函数:

std::mutex& getCommonMutex() {
    static std::mutex m;
    return m;
}

就是这样，你可以从任何地方调用这个函数，它总是会返回对同一个互斥锁的引用，它会在第一次调用时被初始化。