单例模式??通过具体代码实现单例模式的不同实现以及周末总结

小伙伴们大家好，又是一个平平淡淡的周末，先来回顾下这周的情况吧

• 主线开发任务正常，没有滞后
• 首次通过定时任务来处理脚本，测试通过
• 熟悉定时任务的远程，本地来回切换

?2023.12.16? ? ? ? ?天气阴? ? ? ?气温零下

• ??一觉睡到等等 8点？再睡儿会 一觉到九点半，舒服了
• ?刷会儿视频为起床蓄能，老三样，喂，肝，俯
• 看会儿设计模式。。。困死 肝会儿游戏
• 累了，歇会儿睡到两点半，起来敲敲代码
• WeChat 找朋友唠会儿磕
• 晚上就追追剧得了

?

目录

一、简介??

二、代码实例

2.1 单例模式之懒汉式

2.2 单例模式之饿汉式

2.3 单例模式之双重检查

2.4 单例模式之静态内部类

三、总结

---

来分析下今天看的设计模式常用的单例模式

一、简介??

????????单例模式是一种创建型设计模式，其目的是确保一个类只有一个实例，并提供一个全局访问点来获取该实例。

????????在单例模式中，通常会有一个静态方法或静态变量来提供对唯一实例的访问。当第一次调用获取实例的方法时，会创建一个新的实例，并将其保存在静态变量中。之后的每次调用都会返回这个已经创建好的实例。

二、代码实例

2.1 单例模式之懒汉式

? ? ? ? 所谓懒汉式是指用的时候再创建对象，这里的getInstance方法用了synchronized方法修饰，是为了避免多线程情况下，误生成了多个对象

public class LazySignle {

    private static LazySignle lazySignle;

    //私有构造方法，避免外部调用
    private LazySignle(){

    }

    public synchronized static LazySignle getInstance(){

        if(lazySignle == null) {
            lazySignle = new LazySignle();
        }
        return lazySignle;
    }
}

? ? ? ? 创建一个线程类，用来测试下

public class threadTest implements Runnable {

    @Override
    public void run() {
        LazySignle instance = LazySignle.getInstance();
        System.out.println(Thread.currentThread().getName()+"   "+instance.toString());
    }
}

? ? ? ? 启动两个线程，来看下执行结果?

public class LazyTest {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new threadTest());
        Thread thread2 = new Thread(new threadTest());

        thread1.start();
        thread2.start();

        System.out.println("main方法执行完成");
    }
}

? ? ? ? ?根据对象id可以看出是同一个对象

2.2 单例模式之饿汉式

? ? ? ? 饿汉式简单来说就是一开始就将对象创建好

public class HungrySignle {
    private static HungrySignle hungrySignle = null;

    static {
        hungrySignle = new HungrySignle();
    }

    private HungrySignle(){}

    public static HungrySignle getInstance(){
        return hungrySignle;
    }

}

? ? ? ? 线程类，测试类跟懒汉式结构一样，就不放代码了，直接看下测试结果

2.3 单例模式之双重检查

? ? ? ? 双重检查字如其意，进行两次对象是否为空校验，测试结果如下

public class DoubleCheckSignle {
    final static Object lock = new Object();

    private static DoubleCheckSignle doubleCheckSignle;

    private DoubleCheckSignle(){}

    public  static DoubleCheckSignle getInstance(){
        if(doubleCheckSignle == null){
            synchronized (lock){
                if(doubleCheckSignle == null){
                    doubleCheckSignle = new DoubleCheckSignle();
                }

            }
        }
        return doubleCheckSignle;

    }
}

2.4 单例模式之静态内部类

? ? ? ? 静态内部类是指通过内部静态类调用实现单例，测试结果如下

public class StaticInnerClass {

    private static class InnerClass{
        private static StaticInnerClass staticInnerClass = new StaticInnerClass();
    }

    private StaticInnerClass(){}

    public static StaticInnerClass getInstance(){
        return InnerClass.staticInnerClass;
    }
}

三、总结

	饿汉式	懒汉式	静态内部类	双重检查
特点	在类加载时就创建实例，因此是线程安全的。	在首次调用获取实例的方法时才创建实例，延迟初始化。	利用静态内部类的特性，在类加载时不会初始化内部类，只有在第一次调用获取实例的方法时才会初始化。	通过两次检查锁的方式实现线程安全的懒汉式单例。
优点	实现简单，线程安全。	延迟加载，节省资源。	延迟加载，线程安全，无需加锁。	实现延迟加载，线程安全。
缺点	可能会造成资源浪费，如果实例一直没有被使用，会一直占用内存。	多线程环境下需要考虑线程安全性，可能需要加锁。	实现稍微复杂一些。	实现较复杂，需要考虑指令重排序问题。