JAVA 单例模式

文章目录

单例模式

介绍

单例模式的几种实现方式

饿汉式（静态常量、静态代码块）

懒汉式（线程不安全）

懒汉式（线程安全）

双检锁/双重校验锁（线程安全）

静态内部类（线程安全）

枚举（线程安全）

总结

---

介绍

描述

单例模式设计模式属于创建型模式，它提供了一种创建对象的最佳方式，对于一个单一的类，该类负责创建自己的对象，并且确保只有单个对象被创建，对外提供了访问其唯一对象的一种方式。

特点

只能有一个实例、必须自己创建自己的唯一实例、必须给所有其他对象提供这一实例。

适用

单例模式节省了系统资源，通过需要频繁创建销毁的对象，可以提高系统性能，一般使用场景：

1. 需要频繁创建和销毁的对象

2. 创建对象时消耗过多的资源或者耗时太长（重量级对象）

3. 经常使用到的对象（工具类对象[xxxUtils]、频繁访问数据库或文件的对象[session工厂、数据源]）

单例模式的几种实现方式

饿汉式（静态常量、静态代码块）

线程安全：是

Lazy Loading化：否

简述：

优点：写法简单、在类装载的时候就完成实例化、避免了线程同步问题。

缺点：在类装载的时候就完成实例化、没有达到Lazy Loading化、如果未使用到该实例，将会造成内存浪费。

原因：基于classloder机制避免了多线程的同步问题，但是，instance在类装载中就完成了实例化，在单例模式下一般通过调用getInstance()，但是导致类装载方式多种(比如Class的ForName方式)会初始化instance，从而造成内存浪费。

// 饿汉式 - 静态常量
public class Singleton {
    // 1. 构造器私有化，外部不可以new
    private Singleton(){

    }

    // 2. 本类内部创建对象实例
    private final static Singleton instance = new Singleton ();

    // 3. 提供一个公有的静态方法， 返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

// 饿汉式 - 静态代码块
public class Singleton{
    // 1. 构造器私有化，外部不可以new
    private Singleton(){

    }

    // 2. 本类内部创建对象
    private static Singleton instance;

    // 3. 静态代码块中允许，类加载的时候，执行静态代码块
    static {
        new Singleton();
    }

    // 4. 提供一个公有的静态方法， 返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

懒汉式（线程不安全）

线程安全：否

Lazy Loading化：是

简述：

优点：起到了Lazy Loading效果、但是只能在单线程下使用。

原因：多线程条件下，当一个线程进入到了If(instance == null)条件判断中，还未来得及继续执行，另一个线程也通过了条件判断，便会产生多个实例。

public class Singleton{
    // 1. 构造器私有化，外部不可以new
    private Singleton(){

    }

    // 2. 本类内部创建对象
    private static Singleton instance;



    // 4. 提供一个公有的静态方法，当使用到该方法时，才去创建， 返回实例对象
    public static Singleton getInstance() {
        if (instance == null){ // 使用才去创建
            instance = new Singleton();
        }
        return instance;
    }

}

懒汉式（线程安全）

线程安全：是

Lazy Loading化：是

简述：

优点： 通过synchronized关键字，解决了线程不安全问题。

缺点：效率太低。

原因：每个线程在获得类的实例的时候，执行getInstance()方法都要进行同步，实际上该方法仅执行一次即可，此时导致后续线程都需要经过加锁，影响效率。

public class Singleton {
    // 1. 构造器私有化，外部不可以new
    private Singleton (){

    }

    // 2. 本类内部创建对象
    private static Singleton instance;

    // 3. 提供一个公有的静态方法，当使用到该方法时，才去创建， 返回实例对象
    // 加入 锁 ，解决线程安全问题
    public static synchronized Singleton getInstance() {
        if (instance == null){ // 使用才去创建
            instance = new Singleton();
        }
        return instance;
    }

}

双检锁/双重校验锁（线程安全）

线程安全：是

Lazy Loading化：是

简述：

优点： 通过两次If(instance == null)条件判断，保证线程安全。

原因：双重检测，可以保证线程安全，同时volatile关键字可以禁止指令重排，对instance的写操作就会有一个内存屏障，保证在一个写操作的过程，不会有读操作发生。

public class Singleton {
    // 1. 构造器私有化，外部不可以new
    private Singleton(){

    }

    // 2. 本类内部创建对象
    private static volatile Singleton instance;

    // 3. 提供一个公有的静态方法，当使用到该方法时，才去创建， 返回实例对象
    public static Singleton getInstance() {
        if (instance == null){ // 使用才去创建
            synchronized (Singleton.class){
                if (instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }


}

静态内部类（线程安全）

线程安全：是

Lazy Loading化：是

简述：

优点： 避免了线程不安全问题，通过类加载机制保证初始化实例只有一个线程、效率高。

原因：静态内部类方式在外部类被装载时并不会被立即实例化，而是在需要实例化时，调用getInstace()方法，才会装载到外部类中，从而完成instance实例化。

public class Singleton {
    // 1. 构造器私有化，外部不可以new
    private Singleton(){

    }

    // 2. 内部类实例化
    private static class SingletonInner{
        private final static Singleton INSTANCE = new Singleton();
    }

    // 3. 提供一个公有的静态方法
    public static Singleton getInstance() {
        return SingletonInner.INSTANCE;
    }

}

枚举（线程安全）

线程安全：是

Lazy Loading化：是

简述：

优点： 实现单例模式的最佳方法，不仅避免了线程同步问题，而且防止反序列化重新创建新的对象。

public enum Singleton {
    INSTANCE;
    public void methods(){}
}

总结

单例模式一般推荐通过：饿汉式（常用），当明确达到Lazy Loading效果时，建议采用静态内部类，如果设计到反序列化创建对象采用枚举（一般较少出现），特殊情况下采用双重校验方式。