一. 什么是单例模式
单例模式是一种对象创建型模式，使用单例模式，可以保证为一个类只生成唯一的实例对象。也就是说，在整个程序空间中，该类只存在一个实例对象。
其实，GoF对单例模式的定义是：保证一个类，只有一个实例存在，同时提供能对该实例加以访问的全局访问方法。
注：《Design Patterns: Elements of Reusable Object-Oriented Software》（即后述《设计模式》一书），由 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides 合著（Addison-Wesley，1995）。这几位作者常被称为"四人组（Gang of Four）"。
二. 为什么要使用单例模式呢？
在应用系统开发中，我们常常有以下需求：
1.在多个线程之间，比如servlet环境，共享同一个资源或者操作同一个对象。
2.在整个程序空间使用全局变量，共享资源。
3.大规模系统中，为了性能的考虑，需要节省对象的创建时间等等。
因为Singleton模式可以保证为一个类只生成唯一的实例对象，所以这些情况，Singleton模式就派上用场了。
三. 单例模式实现
1. 恶汉式
2. 懒汉式
3. 双重检查
下面看以下程序代码：
package com.susu.singeton;
public class Person {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
主类中进行调用：
package com.susu.singeton;
public class MainClass {
public static void main(String[] args) {
Person person = new Person();
person.setName("吉xx");
Person person2 = new Person();
person2.setName("su");
System.out.println(person.getName());
System.out.println(person2.getName());
/**
* 控制台输出：
* 吉xx
* su
*/
}
}
由程序执行结果，可以看出通过Person类，生成了两个不同的person对象。
那么，如何保证只生成一个对象，我们接下来对以上Person类进行改动。首先将Person类的构造函数私有化，那么就不能再new一个对象，此刻如何获得对象呢？接下来提供一个全局的静态方法，见以下代码。
package com.susu.singeton;
public class Person {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//构造函数私有化
private Person() {
}
//提供一个全局的静态方法
public static Person getPerson() {
return new Person(); //思考：直接返回一个对象，能否起到期望的单例效果。答案是不可以！！
}
}在主类中运行以下程序，同样产生person两个不同的对象。
package com.susu.singeton;
public class MainClass {
public static void main(String[] args) {
//通过类调用静态方法。返回一个person对象。
Person person = Person.getPerson();
person.setName("吉xx");
Person person2 = Person.getPerson();
person2.setName("su");
System.out.println(person.getName());
System.out.println(person2.getName());
/**
* 控制台输出：
* 吉xx
* su
*/
}
}
那么为了保证只生成一个对象，我们可以使用到上面所提到的“饿汉式”方法。定义一个静态的常量person, 只有一份，不能改变（指new Person()这个引用不可以改变，引用中的数据还是可以改变的），在全局静态方法中return person常量。此时代码如下，实现了单例模式。
package com.susu.singeton;
public class Person {
public static final Person person = new Person();
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//构造函数私有化
private Person() {
}
//提供一个全局的静态方法
public static Person getPerson() {
return person;
}
}
主类中进行调用：
package com.susu.singeton;
public class MainClass {
public static void main(String[] args) {
Person person = Person.getPerson();
person.setName("吉xx");
Person person2 = Person.getPerson();
person2.setName("su");
System.out.println(person.getName());
System.out.println(person2.getName());
/**
* 控制台输出：
* su
su
*/
}
}
那么什么是懒汉式呢，我们重新添加一个Person2类。
可以声明一个静态的person，并且在全局的静态方法中增加一个判断，如果不增加判断，会有多个person对象。
package com.susu.singeton;
public class Person2 {
private String name;
private static Person2 person;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//构造函数私有化
private Person2() {
}
//提供一个全局的静态方法
public static Person2 getPerson() {
if(person == null) { //person的初值为null
person = new Person2();
}
return person;
}
}
主类中进行调用
package com.susu.singeton;
public class MainClass {
public static void main(String[] args) {
//Person2测试类
Person2 person = Person2.getPerson();
person.setName("吉xx");
Person2 person2 = Person2.getPerson();
person2.setName("su");
System.out.println(person.getName());
System.out.println(person2.getName());
/**
* 控制台输出：
* su
su
*/
}
}比较饿汉式和懒汉式：饿汉式在类加载的时候就会初始化，赋值，保证了只有一个对象，保证了单例。而懒汉式只有在单线程的时候会保证只有一个对象，在多线程中却不能保证只有一个对象。比如说，当第一个线程进入，判断初始对象为空，于是new一个对象（需要花费一定时间），在这个时间段，第二个线程也进入了，第一个初始化对象还没有完成，同样判断初始对象为null,也会new一个对象返回，这两个返回的对象不再是一个对象了。
为了解决这个问题，需要使用同步方法。新建一个Person3, 仅仅在Person2类中修改静态全局方法即可。当第一个进程进入，独占此方法，初始化完成之后，返回该对象。等到方法结束之后，第二个进程才可以进来。相比于Person2，解决了多线程问题。
package com.susu.singeton;
public class Person3 {
private String name;
private static Person3 person;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//构造函数私有化
private Person3() {
}
//提供一个全局的静态方法，使用同步方法
public static synchronized Person3 getPerson() {
if(person == null) {
person = new Person3();
}
return person;
}
}
主类进行调用：
package com.susu.singeton;
public class MainClass {
public static void main(String[] args) {
//Person3测试类
Person3 person = Person3.getPerson();
person.setName("吉xx");
Person3 person2 = Person3.getPerson();
person2.setName("su");
System.out.println(person.getName());
System.out.println(person2.getName());
/**
* 控制台输出：
* su
su
*/
}
}
下面我们讨论什么是双重检查。通过分析我们上一步的代码，实际上person = new Person()只执行一次，只在第一次的时候，由同步问题，只生成一个对象，第二次、三次都是直接返回person对象。当第一次第一个进程独占一个方法，并且返回person对象时，第二个、三个、四个进程也要排队等待，执行if(person==null)这一判断，影响程序的效率。针对接下来到达的进程，实际上if判断并不要求同步。总体来说，整个方法不需要同步，只在需要同步的地方进行同步。接下来我们可对这一问题进行修改。新建一个Person4类
//提供一个全局的静态方法
public static Person4 getPerson() {
if(person == null) {
synchronized (Person4.class) {
person = new Person4();
}
}
}
return person;
以上代码实际上只做了一次检查，是有问题的。如果两个进程同时到达，都会进入if语句，1进程把持着同步语句，new一个对象，然后返回对象，离开。2进程也会new一个对象，返回对象，离开。此时如果有第三个进程到达，因为已经存在对象，所以直接返回。针对1、2进程可能会出现的问题，因此我们需要在同步中再增加一次检查。第二个if判断针对第一次使用，第一个if判断针对以后使用。
请看双重检查的最终代码。
package com.susu.singeton;
public class Person4 {
private String name;
private static Person4 person;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//构造函数私有化
private Person4() {
}
//提供一个全局的静态方法
public static Person4 getPerson() {
if(person == null) {
synchronized (Person4.class) {
if(person == null) {
person = new Person4();
}
}
}
return person;
}
}主类中进行调用：
package com.susu.singeton;
public class MainClass {
public static void main(String[] args) {
//Person4测试类
Person4 person = Person4.getPerson();
person.setName("吉xx");
Person4 person2 = Person4.getPerson();
person2.setName("su");
System.out.println(person.getName());
System.out.println(person2.getName());
/**
* 控制台输出：
* su
su
*/
}
}
相比于Person3，Person4中new对象只执行一次，实际上代码效率高了很多。
其中，Person类是饿汉式，Person2，Person3，Person4类属于懒汉式，双重检查属于懒汉式的一种，只是对懒汉式的一个改进。相对懒汉式，饿汉式代码编写比较简单，对多线程也是安全的。
最后，我们再回头看单例模式的定义：保证一个类，只有一个实例存在，同时提供能对该实例加以访问的全局访问方法。满足这样要求的就是单例模式。
注：本文参照了北风学习在线的一名老师所讲解的有关单例模式的视频，老师讲的非常好，让我对java各种设计模式有了初步的了解。致敬！