Java设计模式—单例设计模式(Singleton Pattern)全然解析

转载请注明出处：http://blog.csdn.net/dmk877/article/details/50311791

相信大家都知道设计模式，听的最多的也应该是单例设计模式，这种模式也是在开发中用的最多的设计模式，可能有非常多人会写几种设计模式。那么你是否知道什么是设计模式？为什么会有单例设计模式即它的作用是什么？单例模式有哪些写法？对于这种问题。可能有部分童鞋并不能非常好的回答，没关系今天就和大家一起来具体的学习下单例设计模式，相信通过学习本篇你将对单例设计模式有个具体的理解。

如有谬误欢迎批评指正，如有疑问欢迎留言。

通过本篇博客你将学到下面内容

①什么是设计模式

②为什么会有单例设计模式即它的用处,以及它攻克了什么问题

③如何实现单例,即它的设计思想是什么

④单例模式有哪些写法

⑤单例模式在面试中要注意哪些事项

1、什么是设计模式？

   
首先我们来看第一个问题什么是设计模式？在百度百科中它的定义是这种： 设计模式（Design pattern）是一套被重复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。(百度百科)

    事实上设计模式是人们实践的产物，在初期的开发过程中好多人发现再进行反复的代码书写。那些开发大牛们就不断总结、抽取终于得到了大家的认可于是就产生了设计模式，事实上设计模式的种类能够分为23种左右，今天主要和大家一起学习一下单例设计模式，由于这样的设计模式是使用的最多的设计模式。

在以后的文章中会给大家带来其它模式的讨论。

2、为什么会有单例设计模式？

我们都知道单例模式是在开发中用的最多的一种设计模式。那么到底为什么会有单例设计模式呢？对于这个问题相信有非常多会写单例的人都会有个这个疑问。

在这里先说一下单例的用途，然后举一个样例大家就会明确为什么会有单例了。

单例模式主要是为了避免由于创建了多个实例造成资源的浪费。且多个实例由于多次调用easy导致结果出现错误，而使用单例模式能够保证整个应用中有且仅仅有一个实例。从其名字中我们就能够看出所谓单例，就是单个实例也就是说它能够解决的问题是：能够保证一个类在内存中的对象的唯一性，在一些经常使用的工具类、线程池、缓存，数据库，账户登录系统、配置文件等程序中可能仅仅同意我们创建一个对象，一方面假设创建多个对象可能引起程序的错误，还有一方面创建多个对象也造成资源的浪费。

在这样的基础之上单例设计模式就产生了由于使用单例能够保证整个应用中有且仅仅有一个实例，看到这大家可能有些疑惑。没关系，我们来举一个样例，相信看完后你就会非常明确，为什么会有单例。

假如有一个有这么一个需求。有一个类A和一个类B它们共享配置文件的信息，在这个配置文件里有非常多数据例如以下图所看到的

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="">

如上图所看到的如今类ConfigFile中存在共享的数据Num1，Num2，Num3等。假如在类A中改动ConfigFile中数据，在类A中应该有例如以下代码

ConfigFile configFile=new ConfigFile();
configFile. Num1=2;

这个时候configFile中的Num1=2。可是请注意这里是new ConfigFile是一个对象，想象一下在进行了上述操作后类B中进行例如以下操作

ConfigFile configFile=new ConfigFile();
System. out.println("configFile.Num1=" +configFile.Num1);

即直接new ConfigFile();然后打印Num1,大家思考一下这时候打印出的数据为几？我想你应该知道它打印的结果是这种：configFile.Num1=1;也就是说由于每次调用都创建了一个ConfigFile对象，所以导致了在类A中的改动并不会真正改变ConfigFile中的值，它所更改的仅仅是在类A中说创建的那个对象的值。假如如今要求在类A中改动数据后。要通知类B，即在类A和类B中操作的数据是同一个数据，类A改变一个数据，类B也会得到这个数据。并在类A改动后的基础上进行操作。那么我们应该怎么做呢?看到这大家可能会说so
easy,把ConfigFile中的数据设置为静态不就Ok了吗？对，有这样的想法非常好。这样做也没有错。

可是我们都知道静态数据的生命周期是非常长的，假如ConfigFile中有非常多数据时，假设将其所有设成静态的，那将是对内存的极大损耗。所以所有设置成静态尽管可行但并非一个非常好的解决方法。

那么我们应该怎么做呢？要想解决上面的问题。事实上不难，仅仅要能保证对象是唯一的就能够解决上面的问题。那么问题来了怎样保证对象的唯一性呢？这样就须要用单例设计模式了。

3、单例模式的设计思想

在上面我们说到如今解决这个问题的关键就是保证在应用中仅仅有一个对象即可了。那么怎么保证仅仅有一个对象呢？

事实上仅仅须要三步就能够保证对象的唯一性

(1)不同意其它程序用new对象。

由于new就是开辟新的空间。在这里更改数据仅仅是更改的所创建的对象的数据，假设能够new的话，每一次new都产生一个对象，这样肯定保证不了对象的唯一性。

(2)在该类中创建对象

   由于不同意其它程序new对象。所以这里的对象须要在本类中new出来

(3)对外提供一个能够让其它程序获取该对象的方法

由于对象是在本类中创建的。所以须要提供一个方法让其他的类获取这个对象。

那么这三步怎么用代码实现呢？将上述三步转换成代码描写叙述是这种

(1)私有化该类的构造函数

(2)通过new在本类中创建一个本类对象

(3)定义一个公有的方法，将在该类中所创建的对象返回

4、单例模式的写法

经过3中的分析我们理解了单例所解决的问题以及它的实现思想，接着来看看它的实现代码，单例模式的写法大的方面能够分为5种五种①懒汉式②饿汉式③双重校验锁④静态内部类⑤枚举。

接下来我们就一起来看看这几种单例设计模式的代码实现。以及它们的优缺点

4.1单例模式的饿汉式[可用]

public class Singleton {

	private static Singleton instance=new Singleton();
	private Singleton(){};
	public static Singleton getInstance(){
		return instance;
	}
}

訪问方式

Singleton instance = Singleton.getInstance();

得到这个实例后就能够訪问这个类中的方法了。

长处：从它的实现中我们能够看到。这样的方式的实现比較简单。在类载入的时候就完毕了实例化，避免了线程的同步问题。

缺点：因为在类载入的时候就实例化了，所以没有达到Lazy Loading(懒载入)的效果，也就是说可能我没实用到这个实例。可是它

也会载入，会造成内存的浪费(可是这个浪费能够忽略，所以这样的方式也是推荐使用的)。

4.2单例模式的饿汉式变换写法[可用]

public class Singleton{

	private static Singleton instance = null;

	static {
		instance = new Singleton();
	}

	private Singleton() {};

	public static Singleton getInstance() {
		return instance;
	}
}

訪问方式：

Singleton instance = Singleton.getInstance();

得到这个实例后就能够訪问这个类中的方法了。

能够看到上面的代码是依照在2中分析的那三步来实现的。这中写法被称为饿汉式，由于它在类创建的时候就已经实例化了对象。事实上4.2和4.1仅仅是写法有点不同，都是在类初始化时创建对象的。它的优缺点和4.1一样，能够归为一种写法。

4.3单例模式的懒汉式[线程不安全，不可用]

public class Singleton {

	private static Singleton instance=null;

	private Singleton() {};

	public static Singleton getInstance(){

		if(instance==null){
			instance=new Singleton();
		}
		return instance;
	}
}

这样的方式是在调用getInstance方法的时候才创建对象的，所以它比較懒因此被称为懒汉式。

在上述两种写法中懒汉式事实上是存在线程安全问题的，喜欢刨根问题的同学可能会问，存在如何的线程安全问题？如何导致这样的问题的？好，我们来说一下什么情况下这样的写法会有问题。在运行过程中可能存在这么一种情况：有多个线程去调用getInstance方法来获取Singleton的实例。那么就有可能发生这样一种情况当第一个线程在运行if(instance==null)这个语句时，此时instance是为null的进入语句。在还没有运行instance=new
Singleton()时(此时instance是为null的)第二个线程也进入if(instance==null)这个语句，由于之前进入这个语句的线程中还没有运行instance=new
Singleton()，所以它会运行instance=new Singleton()来实例化Singleton对象。由于第二个线程也进入了if语句所以它也会实例化Singleton对象。这样就导致了实例化了两个Singleton对象。所以单例模式的懒汉式是存在线程安全问题的。既然它存在问题，那么可能有解决问题的方法，那么到底怎么解决呢？对这样的问题可能非常多人会想到加锁于是出现了以下这样的写法。

4.4懒汉式线程安全的[线程安全。效率低不推荐使用]

public class Singleton {

	private static Singleton instance=null;

	private Singleton() {};

	public static synchronized Singleton getInstance(){

		if(instance==null){
			instance=new Singleton();
		}
		return instance;
	}
}

缺点：效率太低了。每一个线程在想获得类的实例时候，运行getInstance()方法都要进行同步。而事实上这种方法仅仅运行一次实例化代码就够了，后面的想获得该类实例，直接return即可了。

方法进行同步效率太低要改进。

4.5单例模式懒汉式[线程不安全，不可用]

对于上述缺陷的改进可能有的人会想到例如以下的代码

public class Singleton7 {

	private static Singleton instance=null;

	public static Singleton getInstance() {
		if (instance == null) {
			synchronized (Singleton.class) {
				instance = new Singleton();
			}
		}
		return instance;
	}
}

事实上这样的写法跟4.3一样是线程不安全的。当一个线程还没有实例化Singleton时还有一个线程运行到if(instance==null)这个推断语句时就会进入if语句，尽管加了锁，可是等到第一个线程运行完instance=new
Singleton()跳出这个锁时，还有一个进入if语句的线程相同会实例化另外一个Singleton对象，线程不安全的原理跟4.3类似。因此这样的改进方式并不可行，经过大神们一步一步的探索，写出了懒汉式的双重校验锁。

4.6单例模式懒汉式双重校验锁[推荐用]

public class Singleton {
	/**
	 * 懒汉式变种。属于懒汉式中最好的写法，保证了：延迟载入和线程安全
	 */
	private static Singleton instance=null;

	private Singleton() {};

	public static Singleton getInstance(){
		 if (instance == null) {
	          synchronized (Singleton.class) {
	              if (instance == null) {
	            	  instance = new Singleton();
	              }
	          }
	      }
	      return instance;
	}
}

訪问方式

Singleton instance = Singleton.getInstance();

得到这个实例后就能够訪问这个类中的方法了。

Double-Check概念对于多线程开发人员来说不会陌生。如代码中所看到的。我们进行了两次if (instance== null)检查，这样就能够保    证线程安全了。这样，实例化代码仅仅用运行一次，后面再次訪问时。推断if
(instance== null)。直接return实例化对象。

长处：线程安全。延迟载入。效率较高。

4.7内部类[推荐用]

public class Singleton{

	private Singleton() {};

	private static class SingletonHolder{
		private static Singleton instance=new Singleton();
	} 

	public static Singleton getInstance(){
		return SingletonHolder.instance;
	}
}

訪问方式

Singleton instance = Singleton.getInstance();

得到这个实例后就能够訪问这个类中的方法了。

这样的方式跟饿汉式方式採用的机制类似，但又有不同。

两者都是採用了类装载的机制来保证初始化实例时仅仅有一个线程。不同

的地方在饿汉式方式是仅仅要Singleton类被装载就会实例化。没有Lazy-Loading的作用。而静态内部类方式在Singleton类被装载时

并不会马上实例化，而是在须要实例化时。调用getInstance方法，才会装载SingletonHolder类，从而完毕Singleton的实例化。

类的静态属性仅仅会在第一次载入类的时候初始化。所以在这里，JVM帮助我们保证了线程的安全性。在类进行初始化时，别的线程是

无法进入的。

长处：避免了线程不安全。延迟载入，效率高。

4.8枚举[极推荐使用]

public enum SingletonEnum {

	 instance; 

	 private SingletonEnum() {}

	 public void method(){
	 }
}

訪问方式

SingletonEnum.instance.method();

能够看到枚举的书写非常easy。訪问也非常easy在这里SingletonEnum.instance这里的instance即为SingletonEnum类型的引用所以得到它就能够调用枚举中的方法了。

借助JDK1.5中加入的枚举来实现单例模式。不仅能避免多线程同步问题，并且还能防止反序列化又一次创建新的对象。可能是由于枚举在JDK1.5中才加入，所以在实际项目开发中。非常少见人这么写过，这样的方式也是最好的一种方式，假设在开发中JDK满足要求的情况下建议使用这样的方式。

5、总结

在真正的项目开发中一般採用4.1、4.6、4.7、4.8看你最喜欢哪种写法了，普通情况下这几种模式是没有问题的，为了装逼我一般採用4.6这样的写法，我们经经常使用的Android-Universal-Image-Loader这个开源项目也是採用的4.6这样的写法，事实上最安全的写法是4.8即枚举。它的实现非常easy并且最安全可谓非常完美，可是可能是由于仅仅支持JDK1.5吧又或者是由于枚举大家不熟悉所以眼下使用的人并不多。可是大家能够尝试下。另外当我们使用反射机制时可能不能保证实例的唯一性，可是枚举始终能够保证唯一性。详细请參考次博客：http://blog.csdn.net/java2000_net/article/details/3983958可是普通情况下非常少遇到这样的情况。

6、单例模式的在面试中的问题

单例模式在面试中会经常的被遇到，由于它是考擦一个程序猿的基础的扎实程度的。假设说你跟面试官说你做过项目。面试官让你写几个单例设计模式，你写不出来，你觉着面试官会相信吗？在面试时一定要认真准备每一次面试，靠忽悠即使你被录取了。你也非常有可能会对这个公司不惬意。好了我们言归正传，事实上单例设计模式在面试中非常少有人会问饿汉式写法。一般都会问单例设计模式的懒汉式的线程安全问题。所以大家一定要充分理解单例模式的线程安全的问题，就这几种模式花点时间，认真学透，面试中遇到不论什么关于单例模式的问题你都不会害怕是吧。

假设发现博客中有不论什么问题或者您还有什么疑问欢迎留言，您的支持是我前进的动力

假设本篇博客对你有帮助请赞一个或者留个言呗

转载请注明出处：http://blog.csdn.net/dmk877/article/details/50311791

參考博客：

https://segmentfault.com/q/1010000003732558

http://tianweili.github.io/blog/2015/03/02/singleton-pattern/