单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。
什么是唯一实例？
单例模式的应用场景：
Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？ 不信你自己试试看哦~
windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
网站的计数器，一般也是采用单例模式实现，否则难以同步。
在java中每当我们需要调用对象中的方法或者操作成员变量都需要通过new方法创建一个实例。直接上代码：
package singleDemo;
public class Dog {
}
package singleDemo;
public class Test {
public static void main(String []args){
Dog dog1 = new Dog();
Dog dog2 = new Dog();
System.out.println(dog1 == dog2);
}
}
会发现输出为false，因为java中每创建一个实例对象，都会单独开辟一块内存空间。
要保证我们一个类成为系统的唯一实例，就需要使用单例模式，代码跟上：
package singleDemo;
public class SingleDog {
private SingleDog(){} //构造函数私有化，保证其他地方不能创建该类的实例。
private static SingleDog singleDog = new SingleDog(); //创建一个静态的实例
/**
* 通过公有方法将类的实例返回出去
* @return
*/
public static SingleDog getSingleDog(){
return singleDog;
}
}
package singleDemo;
public class Test {
public static void main(String []args){
SingleDog singleDog1 = SingleDog.getSingleDog();
SingleDog singleDog2 = SingleDog.getSingleDog();
System.out.println(singleDog1==singleDog2); //发现输出为true
}
}
此时发现两个对象完全一样，证明singleDog1 和singleDog2 都指向了同一个实例，这就是所谓的单例模式，有没有很简单的感觉。这种模式也在单例模式中叫做饿汉模式。说到饿汉模式，就要提到单例模式的两种情况：饿汉模式和懒汉模式。
下面我们来看看懒汉模式，直接上代码：
public class SingleDog {
private SingleDog(){} //构造函数私有化，保证其他地方不能创建该类的实例。
private static SingleDog singleDog; //创建一个静态的实例
/**
* 通过公有方法将类的实例返回出去
* @return
*/
public static SingleDog getSingleDog(){
if(singleDog == null){
singleDog = new SingleDog();
}
return singleDog;
}
}
其实就改了一段代码，当我们需要使用类的实例时，我们先看内存中有没有，如果没有的话，我们才创建这个实例。
单例模式l两种方式的优点和缺点：
1.饿汉式：类一加载，对象已经存在，但是浪费内存资源。（开发常用）
2.懒汉式：类加载进来，没有对象，只有调用，才会创建，可以实现 lazy loading。（在多线程下面不安全）
这里笔者不在概述为什么在多线程下不安全，如果不了解的话请补充线程相关知识点。下边懒汉模式是线程安全的写法，直接贴代码。
public class SingleDog {
private SingleDog(){} //构造函数私有化，保证其他地方不能创建该类的实例。
private static SingleDog singleDog; //创建一个静态的实例
/**
* 通过公有方法将类的实例返回出去
* @return
*/
public static synchronized SingleDog getSingleDog(){ //加锁
if(singleDog == null){
singleDog = new SingleDog();
}
return singleDog;
}
}
上面在懒汉模式上可以实现线程安全，但是每次调用都会进行锁的判断，严重影响效率，开发基本不用。难道没有既可以保证线程安全也可以保证懒加载的方式？当然有，我们直接上代码。
public class SingleDog {
private SingleDog(){} //构造函数私有化，保证其他地方不能创建该类的实例。
private static SingleDog singleDog; //创建一个静态的实例
/**
* 通过公有方法将类的实例返回出去
* @return
*/
public static SingleDog getSingleDog(){
if(singleDog == null){
synchronized (SingleDog.class){ //加锁
if(singleDog == null){
singleDog = new SingleDog();
}
}
}
return singleDog;
}
}
我们将锁加在代码块上，这样只有第一次申请对象时才会进行锁的判断，以后申请对象时只会进行空判断， 如果不为空，直接返回了singleDog，不会进行锁的判断，这样实现既保证了效率又保证了线性安全。说到这里单例模式两种基本的实现方式相信大家基本都已经了解了。
总结一下：
1.单例模式保证了内存中唯一对象。
2.单例模式分为饿汉模式和懒汉模式。
3.饿汉模式：在类一加载就申请对象， 浪费内存资源。
4.懒汉模式：在第一次掉才申请对象，可以实现懒加载，在代码块上加上锁。既可以保证效率，也可以实现线程安全。
我们开发时具体是用饿汉模式还是懒汉模式需要根据具体情况而定。笔者水平有限，如果有什么不正确的地方，欢迎联系我纠错。
