Question

所以我有一个类，它以类对象作为参数生成一个线程。然后在线程中我调用一个成员函数。我使用Critical_Sections进行同步。

那么该实现是否是线程安全的？因为只有成员是线程安全的而不是类对象。

    class TestThread : public CThread
    {
    public:
        virtual DWORD Work(void* pData) // Thread function
        {
            while (true)
            {
                if (Closing())
                {
                    printf("Closing thread");
                    return 0;
                }

                Lock();   //EnterCritical
                threadSafeVar++;
                UnLock(); //LeaveCritical

            }
        }

        int GetCounter()
        {
            int tmp;
            Lock();   //EnterCritical
            tmp = threadSafeVar;
            UnLock(); //LeaveCritical

            return tmp;
        }

    private:
        int threadSafeVar;
    };

.
.
.

    TestThread thr;

    thr.Run();

    while (true)
    {
        printf("%d\n",thr.GetCounter());
    }

Answer 1

如果该成员是您的关键部分，您应该只锁定对它的访问权。

顺便说一句，你可以实现一个像以下的储物柜：

class Locker
{
    mutex &m_;

 public:
    Locker(mutex &m) : m_(m)
    {
      m.acquire();
    }
    ~Locker()
    {
      m_.release();
    }
};

你的代码看起来像是：

mutex myVarMutex;
...
{
    Locker lock(myVarMutex);
    threadSafeVar++;
}
...
int GetCounter()
{
    Locker lock(myVarMutex);
    return threadSafeVar;
}

Answer 2

您的实现是线程安全的，因为您已使用互斥锁保护对属性的访问权。

这里，你的类是一个线程，所以你的对象是一个线程。这是你在线程中所做的，它告诉它是否是线程安全的。

您可以通过锁定/解锁系统获得价值，并使用相同的系统进行编写。所以你的函数是线程安全的。

线程安全访问成员变量

2 个答案: