简述：

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

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。
这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

目的

保证一个类有且仅有一个实例，并提供一个访问它的全局访问点。

解决问题

管理一个被高频率使用的类，被频繁的创建和销毁。只用单例能更好的节省程序执行时间和减少空间内存的使用。

单例模式的实现方式有很多种：懒汉式，饿汉式，双锁机制实现，内部类形式，枚举类形式；
最著名的就是：懒汉式和饿汉式。
他们各有各的特点，也各有各的缺点。

1、饿汉式

 

/**
 * 饿汉式 线程安全，运行高效，但长时间占用内存。
 */
public class SingletonDemo1 {
    private static SingletonDemo1 instance = new SingletonDemo1();

    private SingletonDemo1() {
        System.out.print("创建了：SingletonDemo1");
    }

    public static SingletonDemo1 getInstance(){
        return instance;
    }
    public void eventOperation(){
        System.out.print("创建了：SingletonDemo1执行了eventOperation");
    }
}

 

 

2、 懒汉式

**
 * 懒汉式 运行耗时，内存占用少，即用即建。有两种实现方式
 */
public class SingletonDemo2 {
    private static SingletonDemo2 instance;
    private SingletonDemo2() {
        System.out.print("创建了：SingletonDemo2");
    }


    /**
     * 线程安全 多线程使用安全。synchronized作用域为getInstance，每次同步都要面对同步问题，小有耗时。
     * @return
     */
    public static synchronized SingletonDemo2 getInstance() {
        if (null == instance) {
            instance = new SingletonDemo2();
        }
        return instance;
    }


    /**
     * 线程不安全  多线程使用会重复创建
     * @return
     */
    public static SingletonDemo2 getInstance1(){
        if (null == instance) {
            instance = new SingletonDemo2();
        }
        return instance;
    }

    public void eventOperation(){
        System.out.print("创建了：SingletonDemo2  执行了  eventOperation");
    }
}

3、双重锁机制单例模式

 

/**
 * 双重锁机制单例模式，基于懒汉式发展而来。双重锁机制单例模式其实就是双重检查锁定习语下的懒汉式。所以从本质上来说还是懒汉式。
 * 双重锁机制，是指双重检查+同步锁机制。在懒汉式的基础上能更好的提高时效和空间使用，但是并不能从根本上解决多线程创建问题。原因是jvm的内从模型导致双重检查和同步锁失效。
 * 失效的原因是jvm的无序写入问题。所以不建议使用此方式进行单例模式的创建。
 */
public class SingletonDCL {
    private volatile static SingletonDCL instance;
    private SingletonDCL() {
        System.out.print("创建了：SingletonDCL");
    }
    public static SingletonDCL getInstance(){
        /**
         * 检查1
         */
        if (null == instance) {
            /**
             * 同步锁，作用域是创建对象
             */
            synchronized (SingletonDCL.class){
                /**
                 * 检查2
                 */
                if (null == instance) {
                    instance = new SingletonDCL();
                }
            }
        }
        return instance;
    }
    public void eventOperation(){
        System.out.print("创建了：SingletonDCL执行了eventOperation");
    }
}

4、内部类创建方式

/**
 * 内部类创建方式  线程安全，调用效率高，可以延时加载，但是静态内部类有个通病，就是内存泄漏问题。
 */
public class SingletonDemo3 {

    private static final SingletonDemo3 instance = new SingletonDemo3();

    private SingletonDemo3() {
        System.out.print("创建了：SingletonDemo3");
    }

    public static SingletonDemo3 getInstance(){
        return SingletonDemo3.instance;
    }
    public void eventOperation(){
        System.out.print("创建了：SingletonDemo3执行了eventOperation");
    }
}

5、枚举类方式

/**
 * 枚举类方式  稳定，安全，简单优雅，但是不可继承，扩展性差；
 */
public enum SingletonEnum {
    INSTANCE;
    public void eventOperation(){
        System.out.print("创建了：SingletonEnum执行了eventOperation");

    }
}