Question

为了在类之间交换数据，我使用了一种＆＃34; main-hub-class＆＃34;，其他每个类都可以从中访问数据。
现在，为了使这个线程安全，我想出了一个模板化的结构，它包含一个变量和一个boost :: shared_mutex用于该变量：

class DataExchange {
    [...]
    template <typename T>
    struct ShareDataEntry {
            T value;
            boost::shared_mutex _mutex;
    };

    SharedDataEntry<int> ultraSonicValue;
    [...]
}

在.cpp中，我试图像这样使用：

void DataExchange::setUltrasSonicValue(int _value) {
    boost::unique_lock<boost::shared_mutex> lock ( ultraSonicValue._mutex ); // <-- this segfaults
        ultraSonicValue.value = _value;
    lock.unlock();
}

从gdb，我收到错误

__GI____pthread_mutex_lock (mutex=0x58) at pthread_mutex_lock.c:66  
66       pthread_mutex_lock.c: No such file or directory

我做错了什么？我的猜测是互斥锁没有被初始化？但我会怎样（以及在哪里）呢？

修改

更新了代码示例，现在显示我使用的所有内容，同时测试我所描述的问题：

DataExchange.hpp：

#pragma once

#include <boost/thread.hpp>

class DataExchange {
    private:
        DataExchange();
        DataExchange(DataExchange const&) {};
        DataExchange& operator=(DataExchangeconst&) { return *instance; };
        static DataExchange* instance;
        template <typename T>
        struct ShareDataEntry {
                T value;
                boost::shared_mutex _mutex;
        };

        // simple int with extra mutex
        int testIntOne;
        boost::shared_mutex testIntOne_M;

        // int in my struct
        SharedDataEntry<int> testIntTwo;

    public:
        static DataExchange* getInstance();
        ~DataExchange() { delete instance; };

        void setTestIntOne(int _tmp);
        int getTestIntOne();
        void setTestIntTwo(int _tmp);
        int getTestIntTwo();
}

DataExchange.cpp：

#include "infrastructure/DataExchange.hpp"

DataExchange* DataExchange::instance = NULL;

DataExchange::DataExchange() {};

DataExchange* DataExchange::getInstance() {
    if (instance == NULL) instance = new DataExchange;
    return instance;
}

void DataExchange::setTestIntOne(int _tmp) {
    boost::unique_lock<boost::shared_mutex> lock ( testIntOne_M ); // this is now where the segfault occurs
        testIntOne = _tmp;
    lock.unlock();
}

int DataExchange::getTestIntOne() {
    boost::shared_lock<boost::shared_mutex> lock ( testIntOne_M );
    return testIntOne;
}

void DataExchange::setTestIntTwo(int _tmp) {
    boost::unique_lock<boost::shared_mutex> lock ( testIntTwo._mutex );
        testIntTwo.value = _tmp;
    lock.unlock();
}

int DataExchange::getTestIntTwo() {
    boost::shared_lock<boost::shared_mutex> lock ( testIntTwo._mutex );
    return testIntTwo.value;
}

main.cpp中：

#inlcude "infarstructure/DataExchange.hpp"

int main(int argc, char *argv[]) {
    DataExchange* dataExchange = DataExchange::getInstance();

    // this line segfaults already, altough I was pretty sure it worked before
    dataExchange->setTestIntOne(5);
    cout << dataExchange->getTestIntOne() << "\n";

    dataExchange->setTestIntTwo(-5);
    cout << dataExchange->getTestIntTwo() << "\n";

    return 0;
}

是否因为互斥锁未初始化而发生段错误？此外，我非常确定它早期工作，至少是第一种方式（没有结构）。

第二次编辑：
好吧，现在一切都很好。这对我来说是个愚蠢的错误。两种方法都可以完美地工作 - 只要初始化DataExchange对象。

模板化结构中的互斥导致分段错误

0 个答案: