Question

我的应用程序分为一些较小的域，为了减少它们之间的依赖关系，我将使用上下文对象。让我们考虑一个简单的例子：

class SomeType1;
class SomeType2;    
class dummy;

//context for first domain
class foo
{
public:
    virtual void setPtr1 (SomeType1* val) = 0;
    virtual SomeType2* getPtr2 () = 0;

    static foo* getCTX()
    {
        //statement bellow is a singleton which creates one instance of dummy and
        //returns its address as foo*
        return AppCTX::AccessorType<dummy>::getCTX<foo>();
    }
    virtual ~foo();
};

//context for second domain
class bar
{
public:
    virtual void setPtr2 (SomeType2* val) = 0;
    virtual SomeType1* getPtr1 () = 0;
    static bar* getCTX()
    {
         //same as above but casts dummy* to bar*
         return AppCTX::AccessorType<dummy>::getCTX<bar>();
    }
    virtual ~bar();
};

//dummy is a singleton created in AppCTX::AccessorType<dummy>
class dummy: public foo, public bar
{
public:
    virtual void setPtr1 (SomeType1* val)
    {
         ptr1 = val;
    }

    virtual SomeType1* getPtr1 ()
    {
         return ptr1;
    } 

    virtual void setPtr2 (SomeType2* val)
    {
         ptr2 = val;
    }

    virtual SomeType2* getPtr2 ()
    {
         return ptr2;
    } 
    virtual ~dummy();
private:
    SomeType1* ptr1;
    SomeType2* ptr2;
};

我的域启动多个使用上下文的线程，因此可以并行访问ptr1和ptr2。我是否需要将setPtrs和getPtrs与互斥锁同步？ ptr1和ptr2有可能以某种方式被破坏吗？

Answer 1

互斥你的getPtr和setPtr函数并不是很有价值。即使在调用者获得指针并释放互斥锁之后，它仍然可以使用它接收的指针执行任何操作。这肯定会导致多线程出现问题。

您实际上想要将锁定机制放在SomeType1和SomeType2类本身中。例如，您可能会在SomeType1的每个成员函数的开头获取一个互斥锁，然后在每个成员函数返回之前释放互斥锁。

您的某些成员函数可能已经是线程安全的。例如，如果它们不访问成员变量或任何其他共享资源，则线程之间不存在争用的可能性。所以，你不必互斥这些。但是，您需要查看每个成员函数，并问自己如果这些函数使用的成员变量意外更改会发生什么。如果行为是不合需要的，那么该成员函数应该是互斥的。

但是，如果您担心的是实际指针变量本身已损坏，则取决于您正在编译的机器架构。对于许多系统（32位指针的分配是原子操作），这根本不是问题。这个问题得到了更充分的回答here。

上下文对象的同步

1 个答案: