设计模式之单例模式

设计模式之单例模式

介绍

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决：一个全局使用的类频繁地创建与销毁。

何时使用：当您想控制实例数目，节省系统资源的时候。

如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

关键代码：构造函数是私有的。

应用实例：

• 1、一个班级只有一个班主任。
• 2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
• 3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

优点：

• 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
• 2、避免对资源的多重占用（比如写文件操作）。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：

• 1、要求生产唯一序列号。
• 2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
• 3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

代码实现

饿汉式单例模式

实现了单例模式且线程安全，性能也不错，但如果该类初始化时占用巨大的内存资源的话，在其初始化就创建了对象会很占内存空间

public class SingleObject {

    private static SingleObject instance = new SingleObject();

    //构造函数私有
    private SingleObject() {
        System.out.println("线程创建成功");
    }

    //获取唯一对象
    public static SingleObject getInstance() {
        return instance;
    }

    public void PrintSomething(){
        System.out.println("hello");
    }

    public static void main(String[] args) {
        //饿汉式单例模式创建唯一对象
        SingleObject so = SingleObject.getInstance();
        SingleObject so2 = SingleObject.getInstance();
        SingleObject so3 = SingleObject.getInstance();
        System.out.println(so==so2);
        System.out.println(so3==so2);//结果为true证明so so2 so3是同一个对象，实现了单例模式

        //线程安全测试,在SingleObject的构造函数里打印输出语句，经测试只输出一次，证明线程安全
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                SingleObject.getInstance();
            }).start();
        }
    }
}

懒汉式设计模式（线程不安全）

线程不安全，即在多线程下未实现单例模式

public class SingletonTN {
    private static SingletonTN instance;

    private SingletonTN() {
        System.out.println("线程安全测试");
    }

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

    public static void main(String[] args) {

        //线程安全测试,在SingletonTN的构造函数里打印输出语句，经测试不固定次数的打印了输出语句，证明创建了多个对象
        //经测试证明其未实现多线程模式下的单例模式
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                SingletonTN.getInstance();
            }).start();
        }

        //单线程下实现了单例模式
        SingletonTN sl = SingletonTN.getInstance();
        SingletonTN s2 = SingletonTN.getInstance();
        System.out.println(sl == s2);//结果为true证明s1 s2是同一个对象，实现了单例模式
    }
}

懒汉式设计模式（线程安全 synchronized）

实现了单例模式且线程安全，但由于加锁，所以性能上不会很高

public class SingletonTY {
    private static SingletonTY instance;

    private SingletonTY() {
        System.out.println("线程安全测试");
    }

    //加入线程同步关键字synchronized
    public static synchronized SingletonTY getInstance() {
        if (instance == null) {
            instance = new SingletonTY();
        }
        return instance;
    }

    public static void main(String[] args) throws Exception {

        //加入线程同步关键字synchronized后线程安全测试,在SingletonTY的构造函数里打印输出语句，经测试仅仅打印了输出语句一次，证明创建了一个对象
        //实现了多线程单例模式
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                SingletonTY.getInstance();
            }).start();
        }

        //单线程下实现了单例模式
        SingletonTY sl = SingletonTY.getInstance();
        SingletonTY s2 = SingletonTY.getInstance();
        System.out.println(sl == s2);//结果为true证明s1 s2是同一个对象，实现了单例模式

        //利用反射破坏private私有构造函数从而破坏单例模式
        Constructor<SingletonTY> constructor = SingletonTY.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        SingletonTY c1 = constructor.newInstance();
        SingletonTY c2 = constructor.newInstance();
        System.out.println(c1==c2);
    }
}

枚举实现单例模式

线程安全，性能高，简单，也不会被反射破坏单例模式，是很理想的单例模式，缺点为不能懒加载，在不是一定需要懒加载的情况下，使用该方法是最佳的单例实现形式

public enum SingleEnum {
    INSTANCE;

    private SingleEnum() {
        System.out.println("枚举单例初始化");
    }

    public void test() {
        System.out.println("hello");
    }

    public static void main(String[] args) {
        //枚举单例测试，经过测试发现构造方法打印输出了一次，只会创建一次对象所以是单例模式
        SingleEnum.INSTANCE.test();
        SingleEnum.INSTANCE.test();
        SingleEnum.INSTANCE.test();
        SingleEnum.INSTANCE.test();
        SingleEnum.INSTANCE.test();
        //线程安全测试,经过测试构造方法打印输出了一次，只会创建一次对象所以是单例模式
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                SingleEnum.INSTANCE.test();
            }).start();
        }
    }
}

如果明确需要懒加载，可以使用静态内部类的单例模式

public class Singleton {  
    private static class SingletonHolder {  
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    return SingletonHolder.INSTANCE;  
    }  
}

双检锁(还未搞懂)