几种单例模式-Toy模板网

这篇具有很好参考价值的文章主要介绍了几种单例模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

单例模式指的是一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类成为单例类，它提供一个全局访问点。
单例模式有三要素，一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行的向整个系统提供这个实例。

几种单例模式的介绍
基本单例模式

public class Singleton {
    // 基本单例模式实现
    private static  Singleton instance = null; // 提供全局访问的入口

    private Singleton(){ // 构造私有 禁止外部实例化

    }

    public  static  Singleton getSingleton() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

饿汉式

class Singleton1 implements Serializable {
    private Singleton1() {
        if (INSTANCE != null) {
            throw new RuntimeException("单例对象不能重复创建");
        }
        System.out.println("private Singleton1()");
    }

    private static final Singleton1 INSTANCE = new Singleton1();

    public static Singleton1 getInstance() {
        return INSTANCE;
    }
}

懒汉式

class LazySingleton {
    private static LazySingleton instance = null;

    private LazySingleton() { }

    synchronized public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

双检查锁的懒汉式

class LazySingletonDoubleCheck {
    private volatile static LazySingletonDoubleCheck instance = null;

    private LazySingletonDoubleCheck() { }

    public static LazySingletonDoubleCheck getInstance() {
        //第一重判断
        if (instance == null) {
            //锁定代码块
            synchronized (LazySingleton.class) {
                //第二重判断
                if (instance == null) {
                    instance = new LazySingletonDoubleCheck(); //创建单例实例
                }
            }
        }
        return instance;
    }
}

饿汉式和懒汉式的一些优劣
饿汉式单例类在类被加载时就将自己实例化，它的优点在于无须考虑多线程访问问题，可以确保实例的唯一性；从调用速度和反应时间角度来讲，由于单例对象一开始就得以创建，因此要优于懒汉式单例。但是无论系统在运行时是否需要使用该单例对象，由于在类加载时该对象就需要创建，因此从资源利用效率角度来讲，饿汉式单例不及懒汉式单例，而且在系统加载时由于需要创建饿汉式单例对象，加载时间可能会比较长。懒汉式单例类在第一次使用时创建，无须一直占用系统资源，实现了延迟加载，但是必须处理好多个线程同时访问的问题，特别是当单例类作为资源控制器，在实例化时必然涉及资源初始化，而资源初始化很有可能耗费大量时间，这意味着出现多线程同时首次引用此类的机率变得较大，需要通过双重检查锁定等机制进行控制，这将导致系统性能受到一定影响
使用静态内部类的单例模式文章来源地址https://www.toymoban.com/news/detail-722313.html

class Singleton5 implements Serializable {
    private Singleton5() {
        System.out.println("private Singleton5()");
    }

    private static class Holder {
        static Singleton5 INSTANCE = new Singleton5();
    }

    public static Singleton5 getInstance() {
        return Holder.INSTANCE;
    }

    public static void otherMethod() {
        System.out.println("otherMethod()");
    }
}