单例模式（Singleton Pattern） – 设计模式之创建型模式

最新推荐文章于 2024-09-06 11:59:22 发布

天狼1222

最新推荐文章于 2024-09-06 11:59:22 发布

阅读量366

点赞数

分类专栏：设计模式文章标签：设计模式单例模式

本文链接：https://blog.csdn.net/qq_35461948/article/details/114176760

版权

设计模式专栏收录该内容

28 篇文章 2 订阅

订阅专栏

单例模式（Singleton Pattern） – 设计模式之创建型模式：

单例模式（Singleton Pattern）

单例模式（Singleton Pattern）

定义：Ensure a class has only one instance, and provide a global point of access to it.

确保一个类只有一个实例，并提供一个全局访问点。

类图

单例模式通用类图：

单例实现方式：

单例实现的方式有五种：懒汉，恶汉，双重校验锁，静态内部类，枚举。

饿汉：

public class HungrySingle {
    private static HungrySingle instance = new HungrySingle();

    private HungrySingle(){}

    public static HungrySingle getInstance(){
        return instance;
    }
}

private static HungrySingleton instance = new HungrySingleton();

饿汉实现的方式因为加载类的时候就创建实例，所以线程安全(多个ClassLoader存在时例外)。其缺点是不能延时加载。

懒汉：

/**
 *  延迟加载就是在调用get() 方法时实例才被创建
 * */
public class LazySingle {
    // 延迟加载方式
    private static LazySingle lazySingle;

    private LazySingle() {
    }

    public static LazySingle getInstance() {
        // 延迟加载
        try {
            if (lazySingle != null) {

            } else {
                Thread.sleep(3000);
                lazySingle = new LazySingle();
            }

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return lazySingle;
    }

}

懒汉实现的方式每次获取实例的时候，都要进行判断，效率会降低。其优点是延时加载。

双重校验锁：

public class DCLSingle {
    private static DCLSingle dclSingle;

    private DCLSingle() {
    }

    public static DCLSingle getInstance() {
        // 延迟加载
        try {
            if (dclSingle != null) {

            } else {
                Thread.sleep(3000);
                synchronized (DCLSingle.class) {
                    if (dclSingle == null) {
                        dclSingle = new DCLSingle();
                    }
                }
            }

        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return dclSingle;
    }
}

双重校验锁实现的方式，可以实现线程安全，又能够使性能不受很大的影响。在第一次创建实例的时候同步，以后就不需要同步了，从而加快了运行速度。

静态内部类：比较推荐

public class StaticInnerSingle {

    private static class InnerClassSingleHandler {
        private static StaticInnerSingle staticInnerSingle = new StaticInnerSingle();
    };

    private StaticInnerSingle() {
    }

    public static StaticInnerSingle getInstance() {

        return InnerClassSingleHandler.staticInnerSingle;
    }
}

静态内部类实现方式可以延迟加载，减少内存开销。因为用到的时候才加载，避免了静态field在单例类加载时即进入到堆内存的permanent代而永远得不到回收的缺点(大多数垃圾回收算法是这样)。

枚举：推荐的方式

public enum EnumSingle {
    INSTANCE; // 定义一个枚举的元素，它就代表了Singleton的一个实例。
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static void main(String[] args) {
        EnumSingle instance01 = EnumSingle.INSTANCE;
        instance01.setName("yan Master");
        System.out.println(instance01.getName());

    }
}

枚举实现的方式，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。但是失去了类的一些特性，没有延迟加载。