函数是线程安全的吗？

Question

我想避免从进程中的线程多次调用 RegisterClassEx()。为此，我修改了现有功能，如下所示。

当前代码结构对使用替代方法来实现线程安全性施加了限制，因此目前我试图坚持最少的更改。

请让我知道您对以下代码的看法。

foo()
{   
    static ATOM atom = 0;
    if( atom == 0 )
    {
        {
            EnterCriticalSection(&m_CSRegisterClassEx);
            if( atom == 0 )
            {
                atom = RegisterClassEx(&tCls);      

                if( atom == 0)
                {
                    ERROR(L"RegisterClassEx failed! );
                    LeaveCriticalSection(&m_CSRegisterClassEx); 
                    return 0; 
                }
                else
                {
                    ERROR(L"RegisterClassEx good!");
                    LeaveCriticalSection(&m_CSRegisterClassEx);
                    return atom;
                }
            }

        }
    }
    else
    {
        ERROR(L"using atom[%ld] from last call!", atom);
        return atom; 
    }
}   

在此处输入代码

Answer 1

双重检查模式不是线程安全的，请查看这篇文章http://www.aristeia.com/Papers/DDJ_Jul_Aug_2004_revised.pdf

这里有一个解决方案，类似于Qt的Q_GLOBAL_STATIC实现和chrome的signleton实现。

template<class T>
class  TwStaticObject
{
public:
TwStaticObject(void)
    : p(nullptr)
    , x(0)
{

}
~TwStaticObject(void)
{

}

struct Deleter
{
    Deleter(TwStaticObject& This)
    : __this(This)
    {
        ;
    }
    ~Deleter()
    {
        if (__this.p)
        {
            delete __this.p;
            __this.p = 0;
            __this.x = 0;

        }
    }
    TwStaticObject& __this;
};

static T* singletonInstance(TwStaticObject& thisobj)
{ 
    if (InterlockedCompareExchange(&thisobj.x, 1, 0) == 0)
    {
        static T* obj = new T;
        InterlockedExchangePointer((volatile PVOID *)&thisobj.p, (PVOID)obj);
        static Deleter ThisDelter(thisobj);
    }
    else
    {
        while (thisobj.p == nullptr)
        {
            Sleep(0);
        }
    }
    return thisobj.p;
}

T* volatile p ;
volatile long x ;
};


#define  TwDefine_SingleTon(Type, FUN)  \
static TwStaticObject<Type> ThisSingleTon##Type##FUN;\
static Type* FUN()\
{\
    return TwStaticObject<Type>::singletonInstance(ThisSingleTon##Type##FUN);\
}

然后，注册：

class Register{
public:
    Register(){
        atom = RegisterClassEx(&tCls); 
    }

    ATOM atom;
};

TwDefine_Static(Register, _register);

需要时调用 _register()。

Answer 2

这是经典的双重检查锁定。这里的主要问题如下： 比方说，线程一第一次进入函数。检查 atom 为 0，锁定临界区并开始初始化。它将原子设置为非 0，并且此更改反映在主内存中（因为它可以！）。但是，RegisterClass 调用的结果不会反映在主内存中，而是留在 CPU 缓存中。之后，CPU 判断它过热并进入睡眠状态。

在这个完美的时间，另一个线程进入不同 CPU 上的函数。它看到 ATOM 不为空，并愉快地返回它 - 但无论谁要使用该原子，都会大吃一惊！

编辑

刚刚注意到有问题的编译器。由于VS2010不支持线程安全的静态变量，这里还有一个问题。原子可能会被重新初始化为 0 秒。这可能发生在以下情况：

线程一进入函数，检查与原子相关的隐藏“初始化”值，发现它为假，将原子设置为 0，初始化为真，进入临界区并注册类 - 此时它进入睡眠状态。第二个线程进入，检查 inited 值，发现它是假的 - 因为它的一侧没有阅读栅栏，所以它可以读取过时的值 - 并将 atom 设置为 0。需要我继续吗？

明显的解决方案（不是最好的解决方案，但考虑到约束）是在定义静态之前进入临界区。