设计模式之单例模式
文章结构
1.单例模式简介
2.单例模式种类3.参考文章
1.单例模式简介
1.1简介
单例模式，从字面上看是“一个实例”，在系统中单例模式的类只允许生成一个实例*。
百度百科的介绍：单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。
1.2实现思路
单例模式使得该类只能拥有一个实例，我们会把该类的构造方法私有化，来避免使用者重复创建实例，每当使用者使用该实例的时候我们允许其调用该类的静态方法（getINstance()）返回已经创建好的唯一实例；由于将构造方法私有化，该实例的创建也是在该类的方法中完成的，，根据单例模式的写法的不同，该实例的创建方式也不同，创建方式主要分为两种“一种是在类加载的时候完成实例的创建，每次获取该实例时返回该对象的引用；第二种则是获取该实例时，先判断该类实例是否存在，不存在就创建一个 ，存在的话就将这个实例的引用传出去”。所以具体实现有两个关键步骤：
1.类的构造方法私有化。
2.类中存在获取该类实例的一个静态方法：getInstance()。
1.3单例模式使用场景：
在系统中仅需要一个全局对象的时候
某个实例调用频繁且创建耗时耗资源的时候
工具类的对象
2.单例模式种类：
单例模式写法主要分为饿汉模式和懒汉模式两种。饿汉模式即在类加载的时候便创建实例，懒汉模式则是在第一次调用该对象的时候生成实例。由于线程安全的原因，懒汉模式存在多中写法，使用者可以根据应用场景选择对应的写法。下面详细介绍每种写法以及优缺点。
2.1：饿汉模式
优缺点：在类加载的时候就完成实例的创建，以后每次调用getInstance()方法会返回该实例的引用。如果该类一直未被调用就会出现对象已经创建，但无人使用，gc无法回收，导致资源浪费。
/**
* 单例模式-饿汉模式
* @author live
*
*/
public class Singleton_hungry {
// 声明私有变量
private final static Singleton_hungry SINGLETON = new Singleton_hungry();
// 构造函数私有
private Singleton_hungry(){};
// 通过静态方法返回这个单例对象
public static Singleton_hungry getInstance(){
return SINGLETON;
}
}
2.2：懒汉模式-线程不安全
优缺点：该实现方法避免了第一种方法的缺点，当对象被第一次调用的时候才会进行创建，避免了资源的浪费（实现了懒加载）；如果在多线程中，该类未被实例化，此时两个线程同时调用getInstance()方法，在一个线程进入了if(singleton == null)代码块，但是还没有执行实例化的时候，第二个线程也通过了if的判断，就会创建两次该实例，违背了单例模式的原则。所以在多线程中慎用这种模式的写法。
/**
* 单例模式-懒汉模式
* @author live
*
*/
public class Singleton_lazy{
private static Singleton_lazy singleton = null;
private Singleton_lazy(){};
public static Singleton_lazy getInstance(){
// 如果实例未创建，则先创建该实例
if(singleton == null){
singleton = new Singleton_lazy();
}
return singleton;
}
}
2.3：懒汉模式-线程安全-同步方法
优缺点：为了避免第二种写法上的缺点，我们在方法上加同步锁，避免在该类未进行实例化的时候两个线程同时调用，这样就不会产生两个实例，但是这种方法会导致以后每次调用该方法都需要等待锁的释放等，效率比较低。
/**
* 单例模式-懒汉模式
* 线程安全-同步方法延迟加载
* @author live
*
*/
public class Singleton_lazy1{
private static Singleton_lazy1 singleton = null;
private Singleton_lazy1(){};
// 加锁
public static synchronized Singleton_lazy1 getInstance(){
// 如果实例未创建，则先创建该实例
if(singleton == null){
singleton = new Singleton_lazy1();
}
return singleton;
}
}
2.4：懒汉模式-线程安全-同步代码块
优缺点：与同步方法的一样。
/**
* 单例模式-懒汉模式
* 线程安全-同步代码块延迟加载
* @author live
*
*/
public class Singleton_lazy2{
private static Singleton_lazy2 singleton = null;
private Singleton_lazy2(){};
public static Singleton_lazy2 getInstance(){
// 加锁
synchronized (Singleton_lazy2.class) {
// 如果实例未创建，则先创建该实例
if(singleton == null){
singleton = new Singleton_lazy2();
}
}
return singleton;
}
}
2.5：懒汉模式-线程安全-双重检查
优缺点：使用两次if判断进行检查，避免了每次判断都进入同步代码块的情况。实现了线程安全且效率高的优点。具体思路见代码。
/**
* 单例模式-懒汉模式
* 线程安全-双重检查
* @author live
*
*/
public class Singleton_lazy3{
private static volatile Singleton_lazy3 singleton = null;
private Singleton_lazy3(){};
public static Singleton_lazy3 getInstance(){
if(singleton == null){
// 加锁
synchronized (Singleton_lazy3.class) {
// 如果实例未创建，则先创建该实例
if(singleton == null){
singleton = new Singleton_lazy3();
}
}
}
return singleton;
}
}
2.6：匿名内部类
优缺点：与饿汉模式类似，在类加载的时候创建实例，不同的是这种方法是在调用getInstance方法的是时候才会加载静态匿名内部类，实现了延迟加载，而且在静态属性第一次实例化的时候其他线程是无法参与。
public class Singleton_class{
// 构造方法私有
private Singleton_class(){};
// 在内部类进行创建
private static class Create_Singleton_class{
private final static Singleton_class SINGLETON = new Singleton_class();
}
// 返回实例
public static Singleton_class getInstance(){
return Create_Singleton_class.SINGLETON;
}
}
