设计模式之单例模式介绍及实现

单例模式

简单介绍

• 采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）

单例模式的不同写法

饿汉式（静态常量）

应用实例

• 构造器私有化（防止 new)
• 类的内部创建对象
• 向外暴露一个静态的公共方法
• 代码实现

代码

package singleton;

/**
 * @Author: doordiey
 * @Date: Created in 10:40 2020/8/20
 */
public class Singletontest1 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1==singleton2);
    }
}

class Singleton{

    //构造器私有化，外部不能new
    private Singleton(){

    }

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

    //提供公用的静态方法
    public static Singleton getInstance(){
        return instance;
    }
}

优缺点

• 优点：
  • 写法简单，在类装载的时候完成实例化，避免了线程同步问题
• 缺点：
  • 在类装载的时候完成实例化，没有达到lazy loading的效果，如果没有用，会造成内存的浪费
  • 这种方式基于classloader机制避免了多线程的同步问题，不过，instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多种，不能确定有其它方式导致装载
• 结论： 单例模式可用，可能造成内存浪费

饿汉式（静态代码块）

应用实例

• 构造器私有化（防止 new)
• 静态代码块创建实例
• 向外暴露一个静态的公共方法
• 代码实现

代码

package singleton.Test2;

/**
 * @Author: doordiey
 * @Date: Created in 10:48 2020/8/20
 */
public class Singletontest2 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1==singleton2);
    }
}

class Singleton{

    private static Singleton instance;
    //静态代码块执行时，创建单例对象
    static {
        instance = new Singleton();
    }

    //构造器私有化，外部不能new
    private Singleton() {

    }


    //提供公用的静态方法
    public static Singleton getInstance(){
        return instance;
    }
}

优缺点

• 和上面一种方法一样

懒汉式（线程不安全）

应用实例

• 构造器私有化（防止 new)
• 向外暴露一个静态的公共方法（在公共方法中通过if语句判断instance是否为空来创建实例，即使用时创建）
• 代码实现

代码

package singleton.Test3;

/**
 * @Author: doordiey
 * @Date: Created in 10:53 2020/8/20
 */
public class Singletontest3 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1==singleton2);
    }
}

class Singleton{
    private static Singleton instance;

    private Singleton(){}

    //提供一个静态的公共方法，当使用到这个方法时才去创建
    public static Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

优缺点

• 优点：
  • 起到了lazy loading 的效果，但只能在单线程下使用
• 多线程下，可能由于判断语句会产生多个实例
• 实际开发中，不要使用

懒汉式（线程安全）

应用实例

• 构造器私有化（防止 new)
• 向外暴露一个静态的公共方法（在上一种情况下，对公共方法加入同步代码
• 代码实现

代码

package singleton.test4;

/**
 * @Author: doordiey
 * @Date: Created in 10:59 2020/8/20
 */
public class Singletontest4 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1==singleton2);
    }
}

class Singleton{
    private static Singleton instance;
    private Singleton(){}
    
    //加入同步处理，解决线程安全问题
    public static synchronized Singleton getInstance(){
        if (instance==null){
            instance = new Singleton();
        }
        return instance;
    }

}

优缺点

• 解决了线程不安全问题
• 效率太低了，方法进行同步效率太低
• 不推荐使用

懒汉式（线程安全，同步代码块）

应用实例

• 在上一步的情况下，将同步块的位置放到实例化的代码上

代码

class Singleton{
    private static Singleton instance;
    private Singleton(){}
    public static Singleton getInstance(){
        if (instance==null){
            synchronized(instance.class){
            	instance = new Singleton();
            }
        }
        return instance;
    }

}

优缺点

• 不能祈祷线程同步的作用
• 不能使用

双重检查【推荐使用】

应用实例

• 双重检查机制，解决线程安全问题，赖加载问题
• 效率也不错

代码

package singleton.test5;

/**
 * @Author: doordiey
 * @Date: Created in 11:07 2020/8/20
 */
public class Singletontest5 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1==singleton2);
    }
}

class Singleton{
    //通过volatile
    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;
    }
}

优缺点

• 开发中常用
• 实例化代码只执行一次，避免反复进行方法同步
• 线程安全；延迟加载；效率较高
• 推荐使用

静态内部类【推荐使用】

应用实例

• 利用静态内部类

代码

package singleton.test6;

/**
 * @Author: doordiey
 * @Date: Created in 11:13 2020/8/20
 */
public class Singletontest6 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1==singleton2);
    }
}


class Singleton{
    private Singleton(){}

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

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

优缺点

• 采用了类装载的机制保证初始化实例时只有一个线程
• 静态内部类在Singleton被装载时并不会立即实例化，而是在需要实例化的时候，调用getInstance方法，才会装载SingletonInstance类
• 类的静态属性只会在第一次加载类的时候初始化，JVM帮助我们保证了线程的安全性
• 推荐使用

枚举【推荐使用】

应用实例

• 利用枚举

代码

package singleton.test7;


/**
 * @Author: doordiey
 * @Date: Created in 11:21 2020/8/20
 */
public class Singletontest7 {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance==instance2);
    }
}

enum Singleton{
    INSTANCE; // 属性
    public void sayOK(){
        System.out.println("OK");
    }
}

优缺点

• 借助jdk1.5中添加的枚举来实现单例模式，不仅能避免多线程同步问题，还能防止反序列化重新创建新的对象
• 推荐使用

单例模式JDK源码分析

jdk中的java.lang.runtime

代码分析

• 使用了饿汉式 静态常量

Debug源码

代码说明

单例模式注意事项和细节说明

• 保证了系统内存中只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能
• 想实例化一个单例类的时候，必须要记住使用对应的获取对象的方法，而不是使用new

单例模式使用场景

• 需要频繁的进行创建和销毁的对象
• 创建对象时耗时过多或耗费资源过多
• 经常用到的对象
• 工具类对象
• 频繁访问数据库或文件的对象（如数据源，session工厂）