0

为了在类之间交换数据，我使用一种“main-hub-class”，其他类可以从中访问数据。
现在，为了使这个线程安全，我想出了一个模板结构，它包含一个变量和一个 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

我究竟做错了什么？我的猜测是互斥锁没有初始化？但是我将如何（以及在​​哪里）这样做？

编辑

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

数据交换.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();
}

数据交换.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;
}

主.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 对象。

4

0 回答 0