【大道模式】单例模式-Singleton Pattern

最近做项目遇到了一个问题，看了很久都没有得到解决，问题描述如下：
用Java实现了文件上传的后台代码，主要文件是UploadServlet，那么在上传的时候会发现当我上传一个文件的时候会触发多个连接数据库的操作，这样上传多个文件就会触发更多的操作，这样就会是一个遭难，因为数据库连接数过多就会造成以后创建失败。仔细观察一下有问题的伪代码：

public class UploadServlet extends HttpServlet{
	private FileService fileservice ;
	
	public void upload()
	{
		fileservice = new FileService(); //fileService负责对文件的增删查改工作
		fileservice.create(file);       //file是上传文件对象，调用create方法创建数据库连接，写入数据库
	}
}
	

因为在上传多个文件的时候会触发多个uploadservlet类的对象实例，那么每一次触发都会使fileservice去获取新的对象实例，就要开辟空间，建立数据库连接等，因此使用static静态变量来解决问题，让多个上传的对象共享同一个数据库连接，也就是共享同一个对数据库有操作的类的对象fileservice，我们用设计模式中的单件模式来解决这个问题。

可以这么修改代码：

public class FileService{
	private static FileService fileservice;
	
	private FileService(){
		/*do something*/
	}
	
	public static FileService getInstance(){
		if(fileservice==null){         //如果fileservice没有被初始化，那么就new出新的空间
			fileservice = new FileService();    //这句代码只会被执行一次
		}
		return fileservice;    //返回对象唯一的变量fileservice
	}
	/*do something....*/
}

public class UploadServlet extends HttpServlet{
	private static FileService fileservice ;
	
	public void upload()
	{
		fileservice = FileService.getInstance(); //fileService负责对文件的增删查改工作
		fileservice.create(file);       //file是上传文件对象，调用create方法创建数据库连接，写入数据库
	}
}
	

可以解决问题，因为当上传多个文件的时候，即使创建了多个对象，但是这些对象只会共享同一个fileservice，因为它是静态的，而且用单件模式它只会被初始化一次，那么就只会建立一个数据库连接，不会再出现那种数据库连接过多的问题。现在简单介绍一下单件/例模式（Singleton Pattern）：

Java示例：

public class Singleton {
	private static Singleton uniqueInstance;//利用一个静态变量来记录Singleton类的唯一实例
	
	/*把构造函数声明为私有的，只有自己Singleton类内才可以调用构造函数*/
	private Singleton(){
		/* do something... */
	}
	
	public static Singleton getInstance(){
		if(uniqueInstance==null){    //如果uniqueInstance是空的，说明还没有创建实例
			/*如果它不存在，我们就利用私有的构造器产生一个Singleton实例并把它赋值到
			 * uniqueInstance静态变量中。请注意，如果我们不需要这个实例，它就永远
			 * 不会产生。这就是所谓的“延迟实例化”*/
			uniqueInstance = new Singleton();
		}
		/*如果uniqueInstance不是null，就表示之前已经创建过对象。我么就直接跳到return语句*/
		return uniqueInstance;//当执行到这个return，就表示我们已经有了实例，并将uniqueInstance当返回值
	}
}

>单例常常被用来管理共享的资源，例如数据库连接或者线程池。
>优点：可以延迟实例化，这种做法对资源敏感的对象特别重要。

 

C++示例：

Singleton.h文件：

//Singleton.h

#ifndef _SINGLETON_H_
#define _SINGLETON_H_

#include<iostream>
using namespace std;

class Singleton
{
public:
		static Singleton * GetInstance();

private:
		Singleton();
		static Singleton* unique_instance;
};

#endif

Singleton.cc文件：

//Singleton.cc

#include "Singleton.h"

#include<iostream>
using namespace std;

Singleton* Singleton:: unique_instance = NULL;

Singleton::Singleton()
{
	cout<<"singleton constructor"<<endl;
}

Singleton* Singleton:: GetInstance()
{
	if( unique_instance == NULL )
	{
		unique_instance = new Singleton();
	}
	return unique_instance;
}

main.cc文件：

//main.cc

#include<iostream>
#include "Singleton.h"
using namespace std;

int main()
{
	Singleton* sgn1 = Singleton::GetInstance(); 
	Singleton* sgn2 = Singleton::GetInstance(); 
	system("pause") ;
	return 0;
}

运行结果：

可见值调用了一次构造函数。我们通过维护一个static的成员变量unique_instance来记录这个唯一的对象实例。通过提供一个staitc的接口GetInstance()来获得这个唯一的实例。

处理多线程：

       上面给出的代码在单线程的时候工作正常，但在多线程的情况下就会有问题了。设想如果两个线程同时运行到判断uniqueInstance是否为null的if语句，并且uniqueInstance的确没有创建时，那么两个线程都会创建一个实例，此时代码就不能满足单例模式的要求了。为了保证在多线程环境下我们还是只能得到类型的一个实例，需要家伙上那个一个同步锁。把getInstance()变成同步（synchronized）方法，多线程灾难几乎就可以轻易地解决了。

public class Singleton{
		private static Singleton uniqueInstance;
		
		private Singleton(){}
		
		/*通过增加synchronized关键字到getInstance()方法中，我们迫使每个线程在进入这个方法之前，要先等候别的线程离开该方法。也就是说，不会有两个线程可以同时进入这个方法*/
		public static synchronized Singlgeton getInstance{
				if(uniqueInstance == null){
						uniqueInstance = new Singleton();
				}
				return uniqueInstance;
		}
		
		//其他有用的方法
}

这么做可以解决问题但同时降低了性能，为什么？只有第一次执行方法时，才真正需要同步。换句话说，一旦设置好uniqueInstance变量，就不再需要同步这个方法了。之后每次调用这个方法，同步都是一种累赘。

改善多线程性能：

为了符合大多数Java应用程序，很明显地，我们需要确保单件模式能在多线程的状况下正常工作。但是似乎同步getInstance()的做法将拖垮性能，该怎么办？

1.如果getInstance()的性能对应用程序不是很关键，就什么都别做。

如果你的应用程序可以接受getInstance()造成的额外负担，就忘了这件事吧。同步getInstance()的方法既简单又能接受有有效。但是你必须知道，同步一个方法可能造成程序执行效率下降100倍。因此，如果将getInstance()的程序使用子啊频繁运行的地方，你可能就得重新考虑了。

2.使用“急切”创建实例，而不用拖延实例化的做法。

如果应用程序总是创建并使用单件实例，或者在创建和运行时方面的负担不太繁重，你可能想要急切创建此单件，代码：

public class Singleton{
		private static Singleton uniqueInstance = new Singleton();//在静态初始化器（static initialize）中创建单件。这段代码保证了线程安全（thread safe）
		
		private Singleton(){}
		
		public static Singlgeton getInstance{
				return uniqueInstance;  //已经有实例了，直接使用它。
		}
}

利用这个做法，我们依赖JVM在加载这个类时马上创建此唯一的单件实例。JVM保证在任何线程访问uniqueInstance静态变量之前，一定先创建此实例。

3.用“双重检查加锁”，在getInstance()中减少使用同步

利用双重检查加锁（double-checked locking），首先检查是否实例已经创建了，如果尚未创建，“才”进行同步。这样一来，只有第一次会同步，这正是我们想要的。

public class Singleton{
	private volatile static Singleton uniqueInstance;//volatile关键字确保：当uniqueInstance变量被初始化成Singleton实例时，多个线程正确地处理uniqueInstance变量。
	
	private Singleton(){};
	
	public static Singleton getInstance(){ 
		if(uniqueInstance == null){  //检查实例，如果不存在，就进入同步区块。
			synchronized(Singleton.class){
				if(uniqueInstance==null){    //进入区块后，再检查一次。如果仍是null，才创建实例。
					uniqueInstance = new Singleton();
				}
			}
		}
		return uniqueInstance;
	}

}

如果性能是你关心的重点，那么这个做法可以帮你打打地减少getInstance()的时间耗费。

上面的实例是属于懒汉式加载模式，即在获取实例的时候延迟创建对象，那么还有饿汉式加载模式，即在类加载的过程中直接创建实例对象，不存在线程安全问题，下面给出示例：

Singleton1：

/**
 * @description:
 * 饿汉式：直接创建实例对象，不管是否需要这个对象都会创建
 * 1.构造器私有化
 * 2.自行创建，并且用静态变量保存
 * 3.向外提供这个实例
 * 4.强调这是一个单例，用final修饰
 *
 * @create: 2019-09-01 15:14
 **/
public class Singleton1 {

    public static final Singleton1 INSTANCE = new Singleton1();

    private Singleton1(){}
}

Singleton2：

/**
 * @description:
 *     枚举类型：表示该类型的对象是有限的几个
 *     我们可以限定为一个，就成了单例
 * @create: 2019-09-01 15:17
 **/
public enum Singleton2 {
    INSTANCDE
}

Singleton3：

/**
 * @description:
 * @create: 2019-09-01 15:21
 **/
public class Singleton3 {

    public static final Singleton3 INSTANCE;

    static {
        INSTANCE = new Singleton3();
    }

    private Singleton3() {

    }

    public static void main(String[] args) {
        Singleton3 s3 = Singleton3.INSTANCE;
        Singleton3 s4 = Singleton3.INSTANCE;
        System.out.println(s3 == s4);
    }
}

注明出处：【大道模式】单例模式-Singleton Pattern_懂幸福，爱生活-CSDN博客