java中的单例模式

1.设计模式

1.1 什么是设计模式

设计模式是一套被反复利用，多数人知晓的，经过分类编目的，代码设计经验的总结。

1.2 使用设计模式的目的

为了重用代码，让代码更容易让他人理解，保证代码的可靠性。

2.单例模式

2.1 什么情况下用到单例模式？

有些对象只有一个，比如配置文件，工具类，线程池，缓存，日志对象等等。单例模式保证应用中有且只有一个实例。

2.2 常用的单例模式类型

2.2.1 饿汉模式

/**
 * 饿汉模式，因为提供的方法都是静态方法，所有在类加载的时候，唯一的实例就会被加载，这种预先加载的单例模式叫做饿汉模式
 */
public class Singleton {

    /**
     * 将构造方法设置为私有方法
     */
    private Singleton(){}

    /**
     * 在类的内部调用构造方法，生成一个实例
     */
    private static Singleton instance = new Singleton();

    /**
     * 提供一个公共的方法，获取单实例
     */
    public static Singleton getInstance(){
        return instance;
    }
}

测试类：

public class Test {
    public static void main(String[] args){
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();

        System.out.println(s1.toString());
        System.out.println(s2.toString());
    }
}

返回结果：

com.zhaofeng.Singleton@61bbe9ba
com.zhaofeng.Singleton@61bbe9ba

说明确实只有一个实例

2.2.2 懒汉模式

（1）普通的懒汉模式

/**
 * 懒汉模式
 **/
public class Singleton2 {

    /**
     * 1.将构造方法设置为私有方法
     */
    private Singleton2(){}

    /**
     * 2.在类的内部声明一个实例，但是不调用构造方法
     */
    private static Singleton2 instance;

    /**
     * 3.提供一个公共的方法，获取单实例，判断instance是否为空，如果为空，则调用构造方法创建实例
     */
    public static Singleton2 getInstance(){
        if(instance == null){
            instance = new Singleton2();
        }
        return instance;
    }
}

测试类：

/**
 * 懒汉模式
 **/
public class Singleton2 {

    /**
     * 1.将构造方法设置为私有方法
     */
    private Singleton2(){}

    /**
     * 2.在类的内部声明一个实例，但是不调用构造方法
     */
    private static Singleton2 instance;

    /**
     * 3.提供一个公共的方法，获取单实例，判断instance是否为空，如果为空，则调用构造方法创建实例
     */
    public static Singleton2 getInstance(){
        if(instance == null){
            instance = new Singleton2();
        }
        return instance;
    }
}

返回结果：

com.zhaofeng.Singleton2@610455d6
com.zhaofeng.Singleton2@610455d6

说明是同一个实例，但是在多线程的情况下，这种生成的实例不一定只有一个，会导致出现多个实例，这样就违反了单例的初衷。以下提供几种懒汉模式的线程安全的实现。

（2）线程安全的懒汉模式

/**
     * 在getInstance方法上面加同步synchronized，在方法调用上加了同步，虽* 然线程安全了，但是每次都要同步，会影响性能，毕竟99%的情况下是不需* 要同步的
     */
    public static synchronized Singleton2 getInstance(){
        if(instance == null){
            instance = new Singleton2();
        }
        return instance;
    }

    /**
     * 双重检查锁定，在getInstance中做了两次null检查，确保了只有第一次调* 用单例的时候才会做同步，这样也是线程安全的，同时避免了每次都同步的性能损耗
     */
    public static Singleton2 getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton2();
                }
            }
        }
        return instance;
    }

/**
 * 静态内部类，利用了classloader的机制来保证初始化instance时只有一个线程，所以也是线程安全的
 */
public class Singleton {
    private static class LazyHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton (){}
    public static final Singleton getInstance() {
        return LazyHolder.INSTANCE;
    }
}

2.2.3 懒汉模式和饿汉模式的区别

饿汉模式：加载类时比较慢，但是运行时获取对象比较快；线程安全

懒汉模式：加载类时比较快，但是运行时获取对象比较慢；线程不安全