C++｜设计模式（一）｜单例模式与多线程

本文讲解重点在线程安全的懒汉式单例模式

饿汉式单例模式

#include <iostream>
class Singleton {
public:
    static Singleton* getInstance () { //#3获取类的唯一实例对象的入口方法
        return &instance;
    }
private:
    static Singleton instance; // #2定义一个唯一的类的实例对象
    Singleton () { // #1构造函数私有化

    }
    //#4.删除拷贝构造和赋值重载
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};
Singleton Singleton::instance;

int main () {
    Singleton *p1 = Singleton::getInstance();
    Singleton *p2 = Singleton::getInstance();
    Singleton *p3 = Singleton::getInstance();
    std::cout << p1 << " " << p2 << " " << p3 << std::endl;
    //Singleton t = *p1;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

我们通过将实例作为静态变量在其类定义中直接初始化，
饿汉式单例模式的特点就是：程序一经启动，实例对象就已经产生。所以它一定是线程安全的。

原因分析：

• 静态变量的初始化在程序启动时就已经完成，此时还没有其他线程存在，所以该初始化过程肯定是线程安全的。

那么为什么饿汉式单例模式缺点是什么呢？
缺点就在于它在程序启动时就创建对象，然而我们构造函数可能要做的事情很多，很多业务需求并不允许启动程序缓慢，理想的软件设计也应该是在用到时才进行初始化。

懒汉式单例模式

class Singleton {
public:
    static Singleton* getInstance () { //#3获取类的唯一实例对象的入口方法
        if (instance == nullptr) {
            instance = new Singleton;
        }
        return instance;
    }
private:
    static Singleton *instance; // #2定义一个唯一的类的实例对象
    Singleton () { // #1构造函数私有化

    }
    //4删除拷贝构造和赋值重载
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};
Singleton* Singleton::instance = nullptr;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

这里唯一的差别就在于开始先将实例化的对象设为空，只有在我们想要实例化对象时getInstance才会进行实例化。

线程安全的懒汉式单例模式-----方法一

为什么懒汉式单例不是线程安全

我们首先分析一下懒汉式单例模式是不是线程安全的呢？

我们分析的重点就在于getInstance是不是可重入函数，重点分析：

if (instance == nullptr) {
	instance = new Singleton();
}
1
2
3

在堆区构造对象时有以下三步：

1. 开辟内存
2. 构造对象
3. 给instance赋值

如果线程1首先调用getInstance()，此时 instance 肯定为空，所以他会执行1. 开辟内存 2. 构造对象 问题在于，他还没来得及给 instance 赋值，cpu时间片就被线程2抢到了，此时 instance 仍然为空，所以线程2也会执行这三步，这样的话就会导致多个对象的实例化。

第二种可能就在于编译器可能的代码优化，它会先实现开辟内存，然后给instance赋值，最后构造对象。所以另一种可能的静态条件：

1. 开辟内存
2. 给instance赋值
3. 构造对象
   在这种情况下，线程1首先完成了instance赋值，但是还还没来得及构造对象，线程2就拿到了CPU资源，线程2发现 instance 不为空，它就直接执行return instance，线程2竟然返回了一个空的、为经构造 instance 对象!

无论从哪个角度来说，getInstance都是一个可重入函数，所以肯定不是线程安全。

解决线程安全问题

所以我们应该在临界区代码段：

if (instance == nullptr) {
	instance = new Singleton();
}
1
2
3

保持原子操作。

定义一个全局区的互斥锁：

std::mutex mtx;
class Singleton {
public:
	static Singleton* getInstance () {
		lock_guard<std::mutex> guard(mtx);
		if (instance == nullptr) { instance = new Singleton(); }
		return instance;
	}
	...
};
1
2
3
4
5
6
7
8
9
10

但是这样有一个问题，就是锁的粒度太大了，我们在单线程模式下也需要不断得进行加锁解锁。

锁应该放在哪呢？

std::mutex mtx;
class Singleton {
public:
	static Singleton* getInstance () {
		if (instance == nullptr) { 
			lock_guard<std::mutex> guard(mtx);
			instance = new Singleton(); 
		}
		return instance;
	}
	...
};
1
2
3
4
5
6
7
8
9
10
11
12

这样单线程模式下就不会频繁加锁解锁，但是我们再来分析一下，这样枷锁合理吗：
线程1拿到锁，然后new对象，这个时候线程2进来了，由于线程1还没有完成赋值操作，线程2判断 instance == nullptr，所以进入判断逻辑被锁阻塞。等线程1完成赋值操作，返回 instance之后，线程2解除阻塞，仍然在new一个Singleton对象！这样不合理。

所以随后一步改进！

static Singleton* getInstance() {
	if (instance == nullptr) {
		lock_guard<std::mutex> guard(mtx);
		if (instance == nullptr) {
			instance = new Singleton();
		}
	}
	return instance;
}
1
2
3
4
5
6
7
8
9

锁加双重判断，这就是线程安全的懒汉式单例模式。

使用volatile完善

我们再对代码进行分析：

private Singleton* instance;
1

我们这里的instance是在数据段的，属于同一个进程多个线程共享的内存，CPU在执行线程指令的时候，为了加快指令的执行，会让线程把他们共享内存的值都拷贝一份，带到CPU的缓存中，所以堆这个instance最终要的还是加一个volatile关键字（该关键字是给指针加，不是给指针指向加），这个好处就是当某一个线程给这个instance赋值当时候，其他的线程马上看到Instance改变了，因为当前的线程都已经不对这个共享变量进行缓存了，大家看的都是原始内存中的值。

class Singleton() {
public:
	...
private:
	Singleton* volatile instance;
	...
}
Singleton* volatile Singleton::instance = nullptr;
1
2
3
4
5
6
7
8

至此这就是完全的线程安全的懒汉单例模式。

完整代码如下：

std::mutex mtx;
class Singleton {
public:
    // 是不是可重入函数呢？可重入函数值得就是没执行完，可以被再次调用
    static Singleton* getInstance () { //#3获取类的唯一实例对象的接口方法
        if (instance == nullptr) {
            std::lock_guard<std::mutex> guard(mtx);
            if (instance == nullptr) 
                instance = new Singleton;
        }
        return instance;
    }
private:
    static Singleton *instance; // #2定义一个唯一的类的实例对象
    Singleton () { // #1构造函数私有化

    }
    //4删除拷贝构造和赋值重载
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};
Singleton* Singleton::instance = nullptr;

int main () {
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

线程安全的懒汉式单例模式-----方法二

不使用互斥锁的线程安全实现：

class Singleton {
public:
    // 是不是可重入函数呢？可重入函数值得就是没执行完，可以被再次调用
    static Singleton* getInstance () { //#3获取类的唯一实例对象的接口方法
        static Singleton instance; //#2 定义一个唯一的类的实例对象
        return &instance;
    }
private:
    Singleton () { // #1构造函数私有化
    }
    //4删除拷贝构造和赋值重载
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

首先我们的
static Singleton instance; 是定义静态局部变量，其内存在程序启动阶段就有了（在数据段）。但是静态对象第一次初始化是在第一次运行到他的时候才进行初始化。
所以尽管有内存，但是只要我们没有调用getInstance函数，呢么instance对象就不会去构造。

所以他也是一个懒汉式单例模式，那么我们接着分析一下他是不是线程安全的呢？

    static Singleton* getInstance () { 
        static Singleton instance;
        return &instance;
    }
1
2
3
4

从直观上分析，肯定有可能线程1还在调用构造函数，然后线程2也也进入函数开始调用构造函数，但其实：
函数静态局部变量的初始化，在汇编指令上已经自动添加线程互斥指令了，这是C++语言级别为我们保证的。

这里推荐一篇博客：C++设计模式 - 单例模式
最后一部分列出了汇编级的源代码。