设计模式之单例模式

文章结构
1.单例模式简介
2.单例模式种类
3.参考文章

---

1.单例模式简介

1.1简介

单例模式，从字面上看是“一个实例”，在系统中单例模式的类只允许生成一个实例*。
百度百科的介绍：单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。

1.2实现思路

单例模式使得该类只能拥有一个实例，我们会把该类的构造方法私有化，来避免使用者重复创建实例，每当使用者使用该实例的时候我们允许其调用该类的静态方法（getINstance()）返回已经创建好的唯一实例；由于将构造方法私有化，该实例的创建也是在该类的方法中完成的,根据写法的不同，该实例的创建方式也不同，创建方式主要分为两种“一种是在类加载的时候完成实例的创建，每次获取该实例时返回该对象的引用；第二种则是获取该实例时，先判断该类实例是否存在，不存在就创建一个 ，存在的话就将这个实例的引用传出去”。所以具体实现有两个关键步骤：
1.类的构造方法私有化。
2.类中存在获取该类实例的一个静态方法：getInstance()。

1.3单例模式使用场景：

在系统中仅需要一个全局对象的时候
某个实例调用频繁且创建耗时耗资源的时候

工具类的对象

2.单例模式种类：

单例模式写法主要分为饿汉模式和懒汉模式两种。饿汉模式即在类加载的时候便创建实例，懒汉模式则是在第一次调用该对象的时候生成实例。由于线程安全的原因，懒汉模式存在多中写法，使用者可以根据应用场景选择对应的写法。下面详细介绍每种写法以及优缺点。

2.1：饿汉模式

优缺点：在类加载的时候就完成实例的创建，以后每次调用getInstance()方法会返回该实例的引用。如果该类一直未被调用就会出现资源浪费的情况。

/**
 * 单例模式-饿汉模式
 * @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;
    }
}

---

---

3.参考文章：

单例模式的八种写法比较
java单利模式

简书发布地址
博客园发布地址