C++单例设计模式详细讲解

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

classtest

{

public:

statictest* GetObj()

{

returnnewtest();//堆上申请并创建一个对象

}

private:

//构造函数私有

test() { cout <<"调用了构造函数"<< endl; }

//拷贝构造私有化，无法实例化对象

test(consttest& obj){};

};

voidfunc1()

{

test* p = test::GetObj();//通过调用静态函数获取对象的指针

}

1

2

3

4

5

6

7

8

9

10

11

12

13

//只能在栈上创建对象

classtest1

{

public:

statictest1 GetObj()

{

returntest1();//栈上创建一个对象并返回

}

test1() { cout <<"调用了构造函数"<< endl; }

private:

//拷贝构造私有化无法实例化对象

test1(consttest1& obj) { }

};

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

classtest02

{

public:

test02()

{ }

private:

//自定义的定位new、定位delete

void*operatornew(size_tsize)

{

//代码....

}

voidoperatordelete(void*p)

{

//代码....

}

};

1

2

3

4

5

6

7

8

classCopyBan

{

// ...

private:

CopyBan(constCopyBan&);

CopyBan& operator=(constCopyBan&);

//...

};

1

2

3

4

5

classtest

{

private:

test(){}

}

1

2

3

4

classA final

{

// ....

};

1

2

3

4

5

6

7

8

9

10

11

12

13

classSingleton

{

public:

staticSingleton* GetInstance()

{

returnobj;

}

private:

Singleton() {}

Singleton(constSingleton& obj) {}

staticSingleton* obj;

};

Singleton* Singleton::obj =newSinglet on;

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

staticSingleton* GetInstance()

{

//如果只有一层的if判断的我们的程序就会存在一定的问题，

//在多线程的场景下，多个线程都是比较自由的，可读可写、或者只读、只写

//这样在一些场景下就会导致单例对象失去他本身的性质，

//比如：两个线程 th1、th2，同时进入到了if语句中，假设th1会先执行。

//为obj 申请了一个对象并返回它的指针，难么这个实例对象也就创建了

//最后return obj，th1结束后(不确定结束时间)，

//th2又会再次new一个对象给obj,最后导致obj被赋值两次

//整个过程梳理：

//1、th1线程存在内存泄漏，因为obj被赋值两次，而第一次new出来的对象并没有被释放，那么就存在了内存泄漏

//2、obj被赋值两次，失去单例对象性质

if(!obj)

{

if(!obj)

{

obj =newSingleton();

}

}

returnobj;//返回对象的指针

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

staticSingleton* GetInstance()

{

//通过加锁，保证了线程安全

m_mtx.lock();//加锁

//假设th1先拿到锁，那么th1就会先执行下面的语句，而th2就会等待，

//obj就会指向new出来的单例对象，最后th1解锁完了return ,而th2

//才刚拿到锁继续if判断的时候obj已经有值了就会跳过if继续往下执

//行，然后解锁最终return ,整个过程中单例对象只有一份，

//不存在二次赋值

if(!obj)

{

obj =newSingleton();

}

m_mtx.unlock();//解锁

returnobj;//返回对象的指针

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

staticSingleton* GetInstance()

{

if(!obj)

//第一次判断保护线程安全，第二次obj已经有值，不需要执行{....}

//优点：保证线程安全的同时完成了单例对象的初始化

{

m_mtx.lock();//加锁

if(!obj)//保证单例对象只有一份，不会存在二次赋值

{

obj =newSingleton();

}

m_mtx.unlock();//解锁

}

returnobj;//返回对象的指针

}

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

27

28

29

30

31

32

33

34

35

36

37

38

39

40

//懒汉

classSingleton

{

public:

classCGarbo {

public:

~CGarbo() {

if(obj)//释放对象指针，并置空

{

deleteobj;

obj = nullptr;

}

}

};

public:

staticSingleton* GetInstance()

{

//双重检查的好处是保护了线程安全，同时又提高了效率

if(!obj)

{

m_mtx.lock();//加锁

if(!obj)

{

obj =newSingleton();

}

m_mtx.unlock();//解锁

}

returnobj;//返回对象的指针

}

private:

Singleton() {}

Singleton(constSingleton& obj) {}

voidoperator=(constSingleton& obj) {}

staticSingleton* obj;//声明对象指针

staticmutex m_mtx;//声明互斥锁

staticCGarbo Garbo;//声明垃圾回收器对象

};

Singleton* Singleton::obj = nullptr;//对象指针初始化

mutex Singleton::m_mtx;//定义互斥锁

Singleton::CGarbo Garbo;//定义垃圾回收器对象