单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

单例模式按照类型可分为两类：

懒汉模式饿汉模式

通常在写法上包含以下几种：

【懒汉模式一】

// 饿汉模式public class Singleton1 {  private static Singleton1 singleton = null;  private Singleton1() {  }  public static Singleton1 getInstance() {    if (singleton == null) {      singleton = new Singleton1();    }    return singleton;  }}

优点：懒加载启动快，资源占用小，使用时才实例化，无锁。

缺点：非线程安全。

【懒汉模式-线程安全】

public class Singleton {    /**     * 定义一个变量来存储创建好的类实例     */    private static Singleton uniqueInstance = null;    /**     * 私有化构造方法，好在内部控制创建实例的数目     */    private Singleton(){    }    /**     * 定义一个方法来为客户端提供类实例     * @return 一个Singleton的实例     */    public static synchronized Singleton getInstance(){        //判断存储实例的变量是否有值        if(uniqueInstance == null){            //如果没有，就创建一个类实例，并把值赋值给存储类实例的变量            uniqueInstance = new Singleton();        }        //如果有值，那就直接使用        return uniqueInstance;    }    /**     * 示意方法，单例可以有自己的操作     */    public void singletonOperation(){       //功能处理    }    /**     * 示意属性，单例可以有自己的属性     */    private String singletonData;    /**     * 示意方法，让外部通过这些方法来访问属性的值     * @return 属性的值     */    public String getSingletonData(){        return singletonData;    }}

优点：同上，但加锁了。

缺点：synchronized 为独占排他锁，并发性能差。即使在创建成功以后，获取实例仍然是串行化操作。

【懒汉模式-双重加锁检查DCL（Double Check Lock）】

public class Singleton {    /**     * 对保存实例的变量添加volatile的修饰     */    private volatile static Singleton instance = null;    private Singleton(){    }    public static Singleton getInstance(){         // 先检查实例是否存在，如果不存在才进入下面的同步块        if(instance == null){            // 同步块，线程安全的创建实例            synchronized(Singleton.class){                // 再次检查实例是否存在，如果不存在才真的创建实例                if(instance == null){                    instance = new Singleton();                }            }        }        return instance;    }}

优点：懒加载，线程安全。

注：实例必须有 volatile 关键字修饰，其保证初始化完全。

【饿汉模式】

public class Singleton {    // 定义一个静态变量来存储创建好的类实例    // 直接在这里创建类实例，只会创建一次    private static Singleton instance = new Singleton();    // 私有化构造方法，好在内部控制创建实例的数目    private Singleton(){    }    // 定义一个方法来为客户端提供类实例    // 这个方法需要定义成类方法，也就是要加static    // 这个方法里面就不需要控制代码了    public static Singleton getInstance(){        // 直接使用已经创建好的实例        return instance;    }}

优点：饿汉模式天生是线程安全的，使用时没有延迟。

缺点：启动时即创建实例，启动慢，有可能造成资源浪费。

【Holder模式】

public class Singleton {    /**     * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例     * 没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载     */    private static class SingletonHolder{        /**         * 静态初始化器，由JVM来保证线程安全         */        private static Singleton instance = new Singleton();    }    /**     * 私有化构造方法     */    private Singleton(){    }    public static  Singleton getInstance(){        return SingletonHolder.instance;    }}

优点：将懒加载和线程安全完美结合的一种方式（无锁）。（推荐）

备注：

1. 全局共享，独一份；

2. 构造函数不暴露（如果暴露便不能保证一份），自己负责自己的构造；

3. 懒汉式：Lazy load，用到才加载，非线程安全。如何保证线程安全呢：

（1） synchronized getInstance()。

（2）双重检查加锁（volatile）。

4. 饿汉式：一开始就申请好，浪费了点资源，但其线程安全。

5. Holder模式：

（1）改成内部类，由JVM保证线程安全性。

专注于技术热点大数据，人工智能，JAVA、Python、 C 、GO、Javascript等语言最新前言技术，及业务痛点问题分析，请关注【编程我最懂】共同交流学习。