Java设计模式之单例模式

Java设计模式之单例模式

单例设计模式是对于某个类在整个系统中只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法并且是静态方法。解决了一个全局使用的类频繁地创建和销毁。

单列设计模式的七种方式

• 饿汉式（静态常量，可能造成内存浪费）
• 饿汉式（静态代码块，可能造成内存浪费）
• 懒汉式（线程不安全）
• 懒汉式（加入synchronized，线程安全，效率低）
• 懒汉式（双重检查，加入synchronized,和volatile线程安全,同时保证效率，推荐使用）
• 静态内部类（实现懒加载，线程安全，推荐使用）
• 枚举类型

关键代码

• 实现类的构造方法是private
• 向外提供一个静态的公共方法

代码实现

饿汉式（静态常量，可能造成内存浪费）

/**
 * @author yly
 * @ClassName hungrySingleton 饿汉式(可能会造成内存浪费)
 * @Date 2020/2/8 15:45
 * @Version 1.0
 **/
public class HungrySingleton1 {

    private HungrySingleton1() {

    }
    /**
     * 本类内部创建对象实例
     */
    private final static HungrySingleton1 Instance = new HungrySingleton1();
    /**
     * 对外提供一个公有地静态方法
     * @return
     */
    public static HungrySingleton1 getInstance(){
        return Instance;
    }

}

优点：写法简单，类装载时完成实例化，避免线程同步问题
缺点：在类加载时完成实例化，如果系统没有使用此实例，造成内存浪费

饿汉式（静态代码块，可能造成内存浪费）

/**
 * @author yly
 * @ClassName HungrySingleton2 饿汉式（可能造成内存浪费）
 * @Date 2020/2/8 15:50
 * @Version 1.0
 **/
public class HungrySingleton2 {
    private HungrySingleton2() {

    }

    private final static HungrySingleton2 Instance;

    static {
        Instance = new HungrySingleton2();
    }

    public static HungrySingleton2 getInstance() {
        return Instance;
    }

}

懒汉式（线程不安全）

/**
 * @author yly
 * @ClassName idlerSingleton 懒汉式1（线程不安全，不建议使用）
 * @Date 2020/2/8 15:56
 * @Version 1.0
 **/
public class IdlerSingleton1 {
    private IdlerSingleton1() {
    }

    private static IdlerSingleton1 Instance;

    public static IdlerSingleton1 getInstance(){
        if (Instance==null){
            Instance = new IdlerSingleton1();
        }
        return Instance;
    }

}

优点：起到懒加载效果
缺点：只能在单线程下使用，在多线程下可能会产生多个实例，不推荐使用

懒汉式（加入synchronized，线程安全，效率低）

/**
 * @author yly
 * @ClassName IdlerSingleton2 懒汉式2 （加入synchronized,线程安全但是，效率太低，不推荐使用）
 * @Date 2020/2/8 15:59
 * @Version 1.0
 **/
public class IdlerSingleton2 {
    private IdlerSingleton2() {
    }
    private static IdlerSingleton2 Instance;

    public static synchronized IdlerSingleton2 getInstance(){
        if (Instance==null){
            Instance = new IdlerSingleton2();
        }
        return Instance;
    }
}

优点：解决线程安全问题
缺点：效率太低，不推荐使用

懒汉式（双重检查，加入synchronized,和volatile线程安全,同时保证效率，推荐使用）

/**
 * @author yly
 * @ClassName IdlerSingleton3 懒汉式3 双重检查（加入synchronized,和volatile线程安全,同时保证效率，推荐使用）
 * @Date 2020/2/8 16:04
 * @Version 1.0
 **/
public class IdlerSingleton3 {
    private IdlerSingleton3() {
    }

    private static volatile IdlerSingleton3 Instance;

    public static IdlerSingleton3 getInstance() {
        if (Instance == null) {
            synchronized (IdlerSingleton3.class) {
                if (Instance == null) {
                    Instance = new IdlerSingleton3();
                }
            }
        }
        return Instance;
    }
}

优点：线程安全、延迟加载、效率高，推荐使用

静态内部类（实现懒加载，线程安全，推荐使用）

/**
 * @author yly
 * @ClassName StaticClassSingleton 静态内部类（实现懒加载，线程安全，推荐使用）
 * @Date 2020/2/8 16:56
 * @Version 1.0
 **/
public class StaticClassSingleton {
    private StaticClassSingleton() {
    }

    private static class SingletonInstance{
        private static final StaticClassSingleton Instance = new StaticClassSingleton();
    }

    public static StaticClassSingleton getInstance(){
        return SingletonInstance.Instance;
    }
}

• 静态内部类采用类装载机制，保证初始化实例时只有一个线程，静态内部类在被装载时不会立即实例化，而在调用getInstance方法之后才会装载。
  优点：避免线程不安全，利用静态内部类特点实现延迟加载，效率高，推荐使用

枚举类型（推荐使用）

/**
 * @author yly
 * @ClassName EnumSingleton
 * @Date 2020/2/8 17:01
 * @Version 1.0
 **/
public enum  EnumSingleton {

    INSTANCE;

    public void EnumSingleton() {
    }
}

优点：通过枚举实现单例模式，避免多线程同步问题，而且防止反序列化重新创建新的对象，推荐使用。

单例模式在JDK中的应用java.lang.Runtime(饿汉式)

public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}
}

总结：单例模式保证了系统内存中该类只存在一个对象，对于需要频繁创建和销毁的对象，使用单列模式可以提高系统的性能。