设计模式-单例模式-CSDN博客

设计模式-单例模式

文章目录

设计模式-单例模式

概述

所谓设计模式，是一代代伟大的程序员在编写代码时，不断的发掘、积累、总结的23种模式。在编写代码的同时，如果不懂设计模式，很容易到达瓶颈，完成的代码不符合预期的质量。而设计模式恰好可以在编写代码的同时，根据需求完 成质量更好的、更高效 的代码。

对于设计模式的历史，已经有大量资料可供查阅、了解。本章将对设计模式中的 单例模式 进行讲解，并使用代码举栗。

定义

Ensure a class has only one instance, and provide a global point of access to it.（译：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。）
初学者可能会陷入理论盲区一脸懵逼，因为大部分概念比较抽象，不必着急，每个人都会经历这个阶段，请继续阅读。

使用场景：

要求生成唯一序列号的环境；
在整个项目中需要一个共享访问点或共享数据，例如一个Web页面上的计数器，可以不用把每次刷新都记录到数据库中，使用单例模式保持计数器的值，并确保是线程安全的；
创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源；
需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式。

概念小结

简言之就是，避免一个频繁使用的类，反复的在内存被 创建、销毁

至此，结合项目经验，我们应该了解，在项目中，比如有大量工作需要抽象成工具类以便在其他地方使用，假设这个工具类项目中无处不使用，那么按照这个类在使用的时候创建一次，使用后销毁的方式肯定是不够合理的。此时，单例模式应运而生。

演示部分

要实现单例模式，有很多种方法。有线程安全与不安全之分。
以下，我们开始根据代码，以JAVA为例演示如何实现简单的单例：

线程安全

/**
 1. 饿汉式
 2. 类加载到内存后，会实例化一个单例，JVM会保证线程安全
 3. 简单实用，缺点是不用是否用到，都会在类装在的时候完成实例化。在项目中，若大量出现此种单例，可能会造成内存占用过高。
 4. 因此，为合理分配资源，对于每个类如何使用，应充分考虑。
 */
public class Safe1 {
    private static final Safe1 singleton = new Safe1();
    private Safe1() {
    }
    public static Safe1 getInstance() {
        return singleton;
    }
    public static void main(String[] args) {
        Safe1 s1 = Safe1.getInstance();
        Safe1 s2 = Safe1.getInstance();
        System.out.println(s1 == s2);
    }
}

运行输出：true

线程安全2 同上

/**
 * 饿汉式 同上
 */
public class Safe2 {
    private static final Safe2 INSTANCE;

    static {
        INSTANCE = new Safe2();
    }

    public static Safe2 getInstance(){return INSTANCE;}

    public void print(){
        System.out.println("和Safe1一样安全");
    }

    public static void main(String[] args) {
        Safe2 s1 = Safe2.getInstance();
        Safe2 s2 = Safe2.getInstance();
        System.out.println(s1 == s2);
    }
}

懒加载，线程安全

/**
 * 懒加载，线程安全
 * 静态内部类方式
 * 加载外部类时不会加载内部类
 */
public class Safe3 {
    private Safe3() {
    }
    private static class Safe3Holder {
        private final static Safe3 INSTANCE = new Safe3();
    }
    public static Safe3 getInstance()
    {
        return Safe3Holder.INSTANCE;
    }
    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Safe3.getInstance().hashCode());
            }).start();
        }
    }
}

运行结果：可以看到，所有线程的hashCode都相同

使用单例，线程安全,可以防止反序列化

/**
 * 使用单例，线程安全,可以防止反序列化
 * 带来占用内存，占用更多的空间
 */
public enum SafeENUM {
    INSTANCE;
    public void print(String str) {
        System.out.println(str);
    }
    public static void main(String[] args) {
        INSTANCE.print("单例");
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(SafeENUM.INSTANCE.hashCode());
            }).start();
        }
    }
}

运行结果：线程安全

在这里插入图片描述
5. 懒汉式虽然达到了按需初始化的目的，但却带来线程不安全的问题

/**
 * 懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 */
public class UnSafe1 {
    private static UnSafe1 unSafe = null;

    private UnSafe1() {
    }

    public static UnSafe1 getInstance() {
        if (unSafe == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            unSafe = new UnSafe1();
        }
        return unSafe;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() ->
                    System.out.println(UnSafe1.getInstance().hashCode())
            ).start();
        }
    }
}

运行结果：在第一次使用的时候创建，线程不安全
在这里插入图片描述
6. 懒汉式

/**
 * 懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以使用synchronized来保证线程安全，但却带来了效率低下
 */
public class UnSafe2 {

    private static UnSafe2 INSTANCE;
    private UnSafe2(){}

    public static synchronized UnSafe2 getInstance()
    {
        if (INSTANCE == null){
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new UnSafe2();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(UnSafe2.getInstance().hashCode());
            }).start();
        }
    }
}

运行结果：线程不安全
在这里插入图片描述

懒汉式

/**
 * 懒汉式
 * 虽然达到了按需初始化的目的，但却带来了线程不安全的问题
 */
public class UnSafe3 {
    private static UnSafe3 INSTANCE;
    private UnSafe3() {
    }
    public static UnSafe3 getInstance() {
        if (INSTANCE == null) {//妄图通过减小同步代码块的方式提高效率，然而并未达到线程安全的目的，不可行
            synchronized (UnSafe3.class) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new UnSafe3();
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(UnSafe3.getInstance().hashCode());
            }).start();
        }
    }
}

运行结果：并未达到线程安全的目的，且占用内存较高，不可行在这里插入图片描述

懒汉式

/**
 * 懒汉式
 * 虽然达到了按需初始化的目的，但却带来了线程不安全的问题
 */
public class UnSafe4 {
    private static UnSafe4 INSTANCE;

    private UnSafe4() {
    }

    public static UnSafe4 getInstance() {
        if (INSTANCE == null) {//妄图通过减小同步代码块的方式提高效率
            synchronized (UnSafe4.class) {
                if (INSTANCE == null) { // 双重检查，达到了目的但是效率低下
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new UnSafe4();
                }
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(UnSafe4.getInstance().hashCode());
            }).start();
        }
    }
}