设计模式（1）----单例模式

什么是设计模式？

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

使用设计模式的目的：为了代码可重用性，让代码更容易的被他人理解，保证代码的可靠性。设计模式使代码编写真正的工程化；设计模式使软件工程的基石脉络，如同大厦结构一样。

设计模式（Design pattern）代表了最佳的实践，通常被有检验的面向对象的软件开发人员所采用。设计模式是软件开发人员在开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的实验和错误中总结出来的。

设计模式分为三类，共23种：

（1）创建型模式：单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。

（2）结构型模式：适配器模式、桥接模式、装饰器模式、组合模式、外观模式、享元模式、代理模式。

（3）行为型模式：模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（interpreter模式）、状态模式、策略模式、职责链模式（责任连模式）、访问者模式。

设计模式的六大原则（高内聚，低耦合）

（1）单一职责原则：一个类，引起它变化的原因只有一个；即一个类只负责一个功能领域中的相应职责。

（2）开闭原则：一个软件实体（软件实体可以指一个软件模块、一个由多个类组成的局部结构或一个独立的类）应当对扩展开放，对修改关闭。即软件实体应尽量在不修改原有代码的情况下进行扩展。

（3）里氏替换原则：所以引用基类的地方把必须能透明的适用其子类的对象。

（4）依赖倒置原则:抽象不应该依赖于细节，细节应当依赖于抽象。换言之，要针对接口编程，而不是针对实现编程。

（5）接口隔离原则：使用多个专门的接口，而不是使用单一的总接口，即客户端不应该依赖那些它不需要的接口。

（6）迪米特法则：一个软件实体应当尽可能少的与其他实体发生相互作用。

常用的设计模式

其中最常见的设计模式有4个分别是：

（1）单例模式

单例模式主要解决一个全局使用的类的频繁创建和销毁的问题。单例模式下可以确保某一个类的实例，而且该对象由类自行实例化并向整个系统提供这个实例。

（2）工厂模式

工厂模式主要解决的是接口选择的问题。该模式下定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，使其创建过程延迟到子类进行。

（3） 观察者模式

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所以依赖它的对象都得到通知并被自动更新。

（4）装饰器模式

对已存在的某些类进行装饰，依此来扩展一些功能，从而动态的为一个对象增加新的功能。装饰器模式是一种用于代替继承的技术，无需通过继承增加子类就能扩展对象的新功能。使用对象的关联关系代替继承关系，更加灵活，同时避免了类型体系的快速膨胀。

单列模式

单例模式：单列模式使设计模式种最简单的设计模式之一，该模式可以保证一个类仅有一个实例，而且自行实例化并向整个系统提供实例（即不允许用户受用该类的构造函数）。

单例模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

（1）单例类只能有一个实例。

（2）单例类必须自己创建自己的唯一实例。

（3）单例类必须给所有其他对象提供这一实例。

解决问题：一个全局使用类的频繁创建和销毁。

关键代码：构造函数为私有的。

优点：（1）在内存中只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例。

（2）避免了对资源的多重占用。

缺点：没有接口，不能继承。与单一职责原则冲突（一个类应该只关心内部逻辑，而不是关心外面的怎样来实例化）。

单例模式代码实现（c++）

#include <iostream>
using namespace std;
class TestClass
{
public:
	static TestClass* getInstace();
private:
	//将类的构造方法设置为私有方法，使类外不能调用
	TestClass()
	{
		cout << "该类被实例化\n";
	}
	//将复制构造函数和等号运算符同时设置为私有方法
	TestClass(const TestClass&);
	TestClass& operator=(const TestClass&);
	~TestClass()
	{
		instace = NULL;
	}
	static TestClass* instace;
};
//将指针初始化为空，等待用户调用时创建
TestClass* TestClass::instace = NULL;
TestClass* TestClass::getInstace()
{
	if (NULL == instace)
	{
		instace = new TestClass();
	}
	return instace;
}
int main()
{
	TestClass *testClass1 = TestClass::getInstace();
	TestClass *testClass2 = TestClass::getInstace();
	return 0;
}

（1）将构造函数声明为私有的方法，保证类外无法调用。

（2）同时让拷贝构造函数和等号运算符重载函数声明为私有的方法，保证该类在类外无法通过其他方法实例化。

（3）提供静态方法getInstace，保证在没有对象的情况下可以直接使用该类的函数。

（4）使用静态局部变量，在程序中只创建一次，保证只能实例化一个对象。

在上述的例子中，静态局部变量是在使用时才被实例化的，这种类被称为“懒汉式单例类”，即不到万不得已绝不实例化，时间换空间。相对于这一种方式还有方式的单例类被称为“饿汉式单例类”，即在单例类定义时就将该类实例化，空间换时间。

#include <iostream>
using namespace std;
class TestClass
{
public:
	static TestClass* getInstace();
private:
	TestClass()
	{
		cout << "饿汉式单例类\n";
	}
	TestClass(const TestClass&);
	TestClass& operator=(const TestClass&);
	~TestClass()
	{
		instace = NULL;
	}
	static TestClass* instace;
};
TestClass* TestClass::instace = new TestClass();
TestClass* TestClass::getInstace()
{
	//防止对象被析构后无法再次创建
	if (NULL == instace)
	{
		instace = new TestClass();
	}
	return instace;
}
int main()
{
	TestClass* testClass1 = TestClass::getInstace();
	TestClass* testClass2 = TestClass::getInstace();
	return 0;
}

 在单线程中使用这两种方式都是没有问题的，但在多线程中就会存在线程不安全的问题。在分析这个问题之前首先需要明白：

在上面的代码中我们使用了TestClass类的静态局部变量instace（指针），静态局部变量存放在内存中的全局数据区，当整个程序结束后才会被释放掉。而我们知道在同一个进程中的多个线程会共享全局数据区，这就会使得线程会共享instace变量。

分析代码：

TestClass* TestClass::getInstace()
{
        //当instace为空时，可能同时会有多个线程进入该if结构中，这样就会实例化出多个对象。(概率很小，但存在可能)
	if (NULL == instace)
	{
		instace = new TestClass();
	}
	return instace;
}

那如何保证线程安全那？

最简单的方法就是加锁，通过锁机制保证同一时刻只有一个线程进入if结构中。

TestClass* TestClass::getInstace()
{
    pthread_mutex_lock(&pthreadMutex);
    if (NULL == instace)
    {
	instace = new TestClass();
    }
    pthread_mutex_unlock(&pthreadMutex);
    return instace;
}

加锁会导致效率变低，可能会导致同时有多个线程阻塞在加锁处，所有有人提出一种方案解决这个问题，这就是双重锁定机制：

TestClass* TestClass::getInstace()
{
    //减少进入的线程数，从而减少阻塞的线程数。
    if(NULL==instace)
    {
        //保证同时只有一个线程进入
        pthread_mutex_lock(&pthreadMutex);
        //保证只能实例化出一个对象
	if (NULL == instace)
	{
	    instace = new TestClass();
	}
        pthread_mutex_unlock(&pthreadMutex);
    }
    return instace;
}

对于多线程下的“懒汉式单列类”在一开始就会遇见线程不安全的问题，但“饿汉式单例类”是在对象被析构后才会遇到这样的问题，如果一个类在程序运行时只需要实例化一次，而且在程序运行期间不会被析构，那么就可以考虑采用下面这样的“饿汉式单例类”：

TestClass* TestClass::getInstace()
{
    //在类定义时直接实例化，之后直接返回。
    return instace;
}

适合于服务器一类的程序使用。设计模式是一种解决问题的方法，和使用什么语言无关。