JVM--使用单例来提升系统性能

单例模式是面试常客，如果考察设计模式，那么有很大可能会考单例模式，因为单例模式看似简单，每个人可能都可以写出来，不过如果往深挖，又能考察出候选人对于并发、类加载、序列化等重要知识的掌握水平。单例模式有很多种写法。单例模式有很多种写法，它们分别有哪些坑呢？哪种写法更好，为什么呢？

为什么需要单例模式：

• 理由一：节省内存、节省计算

      例如：下面类初始化是需要查询数据库，并对查到的数据做大量的计算，所以在第一次构造的时候，花了很多时间来初始化这个对象；
      但是假设我们数据库里的数据是不变的，并且把这个对象保存在了内存中，那么以后就可以用同一个实例了。
      如果每次都重新生成新的实例，实在是没有必要。

      

public class ExpensiveResource {

    public ExpensiveResource() {
        field1 = // 查询数据库
        field2 = // 然后对查询的数据库做大量计算
        field3 = // 加密、压缩等耗时操作
    }


}

 

• 理由二：保证结果的正确

    例如：一个全局计数器，用来统计人数，那么有多个实例的话反而会造成混乱。

• 理由三：方便管理

    例如：很多工具类，我们只需要一个实例，那么我们通过一个统一的入口，比如通过getInstance 方法，获取到单例，很方便

 

单例模式适用场景：

• 无状态工具类 ：

1. 日志工具类 只是用于记录日志信息，不需要在操作类实例对象上存储任何状态
2. 字符串工具

• 全局信息类

1. 全局计数
2. 环境变量

单例模式的写法：

饿汉式

 

/**
 * 类装载的时候就完成了实例化，避免了线程同步的问题；
 * 缺点在于类装载的时候就完成了实例化，没有达到懒加载的效果；
 * 如果一直未使用该实例，就造成了内存浪费。
 */
public class Singleton {
    private static Singleton singleton = new Singleton();

    private Singleton() {
    }

    public static Singleton getInstance() {
        return singleton;
    }
}

 

//静态代码块式写法

public class Singleton {
    private static Singleton singleton;

    static {
        singleton = new Singleton();
    }

    private Singleton() {
    }

    public static Singleton getInstance() {
        return singleton;
    }
}

 

 

 懒汉式

/**
 * 线程不安全式写法：
 *调用时进行实例化，起到懒加载效果，只能在单线程下使用，避免多线程环境下使用该写法 
 */

public class Singleton {
    private static Singleton singleton;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (singleton == null) {  //多线程进入会产生多实例
            singleton = new Singleton();
        }
        return singleton;
    }
}

public class Singleton {
    private static Singleton singleton;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (singleton == null) {  //多线程进入会产生多实例
            synchronized (Singleton.class) {
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}

/**
 * 线程安全式写法：
 * 效率太低
 */


public class Singleton {
    private static Singleton singleton;

    private Singleton() {
    }

    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

 

 双重检查式

/**
 * 线程安全式写法：
 * 两个if判断，第二次if判断会跳过if代码块，直接return 实例化对象；优点不仅线程安全，而且延迟加载，效率更高。缺点不能防止被反序列化，生成多个实例。
 *
 * 扩展思考1：为什么要double-check? 去掉第二次的check行不行呢？
 *
 * 思考：两个线程同时调用getInstance方法，并且由于singleton是空的，所以两个线程都可以通过第一重的if判断，
 * 然后由于锁机制的存在，会有一个线程先进入同步语句，并进入第二重的if判断，而另一个线程就会在外面等待，
 * 不过当第一个线程执行完 new Singleton() 语句后，就会退出 synchronized 保护的区域，如果没有第二重singleton == null的话，
 * 那么第二个线程也会创建一个实例，这就破坏了单例；
 * 如果第一check去掉，那么所有线程都会串行执行，效率低下，所以两个check都需要保留的。
 *
 * 扩展思考2：为什么要加volatile关键字？
 *
 * 思考：主要在于singleton = new Singleton() 不是原子操作。防止了JVM中重排序的发生，避免了1->3->2顺序执行过程中拿到未完成初始化的对象。
 *
 * 在JVM中代码执行步骤：
 * 1）给singleton分配初始空间；
 * 2）调用Singleton的构造函数等来初始化singleton；
 * 3）将singleton对象指向分配的内存空间（执行完这步singleton就不是 null 了）。
 *
 * 由于JVM中存在==重排序现象==，执行熟悉存在 1->3->2 或者 1->2->3
 */


public class Singleton {
    private static volatile Singleton singleton;

    private Singleton(){}

    public static  Singleton getInstance(){
        if(singleton == null){
            synchronized (Singleton.class){
                if(singleton == null){  //多线程进入会产生多实例
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

 

静态内部类式

/**
 * 饿汉式机制类似，采用类装载机制，来保证我们初始化实例时只有一个线程，所以JVM保证了线程的安全性；
 * 不会在类装载时实例化，而是在需要调用时实例化。优点不仅线程安全，而且延迟加载，效率更高。
 * 缺点不能防止被反序列化，生成多个实例。
 */
public class Singleton {

    private Singleton() {
    }

    private static class SingletonInstance {
        private static final Singleton singleton = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonInstance.singleton;
    }
}

 

枚举式

/**
 * 1.写法简单，代码短小精悍，代码更简洁更优雅；
 * 2.线程安全有保证，枚举中的各个枚举项都是通过static代码来定义和初始化的，
 * 他们会在类被加载时完成初始化，而Java类的加载由JVM保证线程安全，所以创建一个Enum 类型的枚举是线程安全的。
 * 3.防止单例破坏，java专门对枚举序列化做了规定，在序列化是仅仅是将枚举对象的name属性输出到结果中，
 * 在反序列化时，就是通过java.lang.Enum的valueOf来根据名字查找对象，而不是新建一个新的对象，所以防止了反序列化。
 */
public enum Singleton {
    INSTANCE;

    public Singleton getInstance() {
        return INSTANCE;
    }

}

 

 

枚举式代码的例子

/**
 * 描述： 枚举式单例的写法
 */
public enum Singleton {
    INSTANCE;

    public void whatever() {
        System.out.println("执行了单例类的方法，例如返回环境变量信息");
    }
    public static void main(String[] args) {
        //演示如何使用枚举写法的单例类
        Singleton.INSTANCE.whatever();
    }
}