标签： 多线程

在前一部分(从单例模式谈起(一))我们讨论单例模式时，谈到了 Double-Checked Locking 问题。我们讲， volatile 关键字并不能解决Double-Checked Locking 问题。这一节我们讨论与此相关的问题。
现代编译器为了提高程序的效率而对代码做了很多优化。这些优化大部分是有益的，但是也为多线程编程带来问题。

寄存器缓存

我们来看如下代码：

x = 0;
Thread1 {
    lock();
    x++;
    unlock();
}
Thread2 {
    lock();
    x++;
    unlock();
}

x++ 的值有锁保护，所以它是独占的，x++ 的行为不会被并发破坏。那么 x 的值必然为 2。 然而现实中并非一定如此：编译器有可能为了提高 x 的访问速度而将 x 放入线程的某个寄存器中，而线程的寄存器是线程私有的。 如果 Thread1 先获得了锁，那么程序的执行过程有可能是这样的：

1. [Thread1] 读取 x 到寄存器 R₁. (R₁ = x = 0)
2. [Thread1] R₁++. unlock. 由于之后可能还会访问 x, 所以 Thread1 不将 R₁ 写回 x . (x = 0)
3. [Thread2] 读取 x 到寄存器 R₂ (R₂ = x = 0)
4. [Thread2] R₂++
5. [Thread2] 将 R₂ 写回 x (x = R₂ =1)
6. [Thread1] 在某个时候将 R₁ 写回 x (x = R₁ = 1)

由此可见，即使正确的加了锁，也不能保证多线程安全。

（更多…）

单例模式可能是大家最为熟知的一种设计模式，本身没什么好谈的。但是在 C++ 中，由单例模式可以引出一系列的问题，可能会比较有意思，这里探讨一下。

常见的简单实现

1.使用 static 实现

class S1 {
    public:
        static S1& GetInstance() {
            static S1 s;
            return s;
        }   
        void fun() {}

    private:
        S1(){cout<<"S1 inited"<<endl;}
        S1(const S1&) = delete;
        S1& operator=(const S1&) = delete;
};

class S2{ 
    public:
        static S2& GetInstance(){
            return s;
        }   
        void fun(){}
    private:
        S2(){cout<<"S2 inited"<<endl;}
        //...
    private:
        static S2 s;
};
S2 S2::s;

其中 S2 是要避免的。因为 1. 类的静态成员变量的初始化时间一般早于 main 函数 2. 如果静态成员的初始化里调用了其它类，可能出现未定义的错误。

2.使用指针判断是否初始化

class S3{
    public:
        static S3& GetInstance(){
            if(s == 0)
                s = new S3();
                 return *s;
        }

    private:
        S3(){}
        static S3 *s;
};

这两种方式在单线程程序中使用都是可以的，但如果在多线程中，就会出现问题。

Magic Static

对于 S1 要注意， C++ 局部静态变量的初始化可能不是线程安全的 ， 这就是 Magic Static ，是指 返回一个静态局部变量的引用 的用法，在某些情况下，如S1 可能会被编译器这样解析:

（更多…）