设计模式学习第一天：8种单例设计模式

最新推荐文章于 2024-07-25 10:44:49 发布

唐小码

最新推荐文章于 2024-07-25 10:44:49 发布

阅读量143

点赞数

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

本文链接：https://blog.csdn.net/qq_35712465/article/details/118378839

版权

23种设计模式专栏收录该内容

2 篇文章 0 订阅

订阅专栏

源码地址：https://gitee.com/tangruiguo/designmodel.git

参考尚硅谷韩顺平老师讲的设计模式

一、基础概念

1、什么是单例设计模式？

在整个软件系统中，某个类只存在一个对象实例。且该类通过静态方法只提供一种取得实例的方法。

举例：

比如 Hibernate 的 SessionFactory，它充当数据存储源的代理，并负责创建 Session 对象。SessionFactory 并不是轻量级的，一般情况下，一个项目通常只需要一个 SessionFactory 就够，这是就会使用到单例模式。

2、单例的使用场景

使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session 工厂等)

二、单例设计模式的八种方式

单例模式有八种方式：

1) 饿汉式(静态常量)

2) 饿汉式（静态代码块）

3) 懒汉式(线程不安全)

4) 懒汉式(线程安全，同步方法)

5) 懒汉式(线程安全，同步代码块)

6) 双重检查

7) 静态内部类

8) 枚举

1、饿汉式（静态常量）（可用）

package com.trg.designmodel.singleleton;

/**
 * @ClassName: SingleLetonTest01
 * @Description: 单例设计模式-饿汉式
 * @Author: tangrg
 * @Date: 2021/6/30 14:41
 * @Version: 1.0
 * @Return:
 **/
public class SingleLetonTest01 {
    public static void main(String[] args) {
        SingleLeton instance = SingleLeton.getInstance();
        SingleLeton instance2 = SingleLeton.getInstance();
        System.out.println(instance == instance2);
        System.out.println("instance:"+instance.hashCode());
        System.out.println("instance2:"+instance2.hashCode());

    }

}

class SingleLeton {
    //***1、私有化构造器，防止外部new
    private SingleLeton() {
    }

    //***2、类内部创建静态实例
    private final static SingleLeton instance = new SingleLeton();

    //***3、提供一个公有的静态方法，将实例对象返回
    public static SingleLeton getInstance() {
        return instance;
    }
}

>>>>>总结<<<<<<：

优点：写法简单，在类装载的时候就完成了实例化，避免了线程同步问题

这里提一嘴类装载：类加载的完整过程是加载--》链接（1、验证、2、准备、3、解析）---》初始化三个阶段。在准备阶段，为类变量分配内存并且设置该类变量的默认初始值，即零值，在初始化的时候正式分配值。但是如果静态变量在前面加了final，则在编译的时候就分配好了默认值。准备阶段会显示初始化

缺点：在类装载的时候就完成了实例化，如果从始至终都没有用到这个实例，则会造成内存的浪费，应该达到Lazy Loading的效果。

这种方式基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数都是调用 getInstance 方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 就没有达到 lazy loading 的效果

结论：这种单例模式可用，可能造成内存浪费

2、饿汉式（静态代码块）（可用）

package com.trg.designmodel.singleleton;

/**
 * @ClassName: SingleLetonTest02
 * @Description: 单例设计模式-饿汉式（静态代码块）
 * @Author: tangrg
 * @Date: 2021/6/30 14:58
 * @Version: 1.0
 * @Return:
 **/
public class SingleLetonTest02 {

    public static void main(String[] args) {
        SingleLeton02 instance = SingleLeton02.getInstance();
        SingleLeton02 instance2 = SingleLeton02.getInstance();
        System.out.println(instance == instance2);
        System.out.println("instance:"+instance.hashCode());
        System.out.println("instance2:"+instance2.hashCode());
    }

}

class SingleLeton02 {
    //***1、私有化构造器
    private SingleLeton02() {
    }

    private static final SingleLeton02 instance;

    //***2、在静态代码块中创建实例对象
    static {
        instance = new SingleLeton02();
    }

    //***3、提供一个公有的静态方法，将实例对象返回
    public static SingleLeton02 getInstance() {
        return instance;
    }
}

>>>>>总结<<<<<<：

1) 这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。

2) 结论：这种单例模式可用，但是可能造成内存浪费

3、懒汉式（线程不安全）

package com.trg.designmodel.singleleton;

/**
 * @ClassName: SingleLetonTest03
 * @Description: 单例设计模式-懒汉式（线程不安全）
 * 懒汉式，故名思意，比较懒，默认的时候不加载，只有在被调用的时候才会加载
 * @Author: tangrg
 * @Date: 2021/6/30 15:19
 * @Version: 1.0
 * @Return:
 **/
public class SingleLetonTest03 {
    public static void main(String[] args) {
        SingleLeton03 instance = SingleLeton03.getInstance();
        SingleLeton03 instance2 = SingleLeton03.getInstance();
        System.out.println(instance == instance2);
        System.out.println("instance:" + instance.hashCode());
        System.out.println("instance2:" + instance2.hashCode());
    }
}

class SingleLeton03 {

    //***1、私有化构造器，防止外部类new
    private SingleLeton03() {
    }

    private static SingleLeton03 instance;

    //***3、提供一个公有的静态方法，将实例对象返回
    public static SingleLeton03 getInstance() {
        //**** 只有在被调用的时候才会进行创建，否则不创建
        if (instance == null) {
            instance = new SingleLeton03();
        }
        return instance;
    }
}

>>>>>总结<<<<<<：

起到了Lazy Loading的作用，但是只能在单线程下使用
如果在多线程下，一个线程进入了 if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式

结论：

实际项目中，不推荐使用

4、懒汉式（线程安全-同步方法）

package com.trg.designmodel.singleleton;

/**
 * @ClassName: SingleLetonTest04
 * @Description: 单例设计模式-懒汉式（线程安全-同步方法）
 * @Author: tangrg
 * @Date: 2021/6/30 15:55
 * @Version: 1.0
 * @Return:
 **/
public class SingleLetonTest04 {

    public static void main(String[] args) {
        SingleLeton04 instance = SingleLeton04.getInstance();
        SingleLeton04 instance2 = SingleLeton04.getInstance();
        System.out.println(instance == instance2);
        System.out.println("instance:" + instance.hashCode());
        System.out.println("instance2:" + instance2.hashCode());
    }
    
}

class SingleLeton04 {
    //***1、私有化构造器
    private SingleLeton04() {
    }

    private static SingleLeton04 instance;

    /**
     * 由于该方法被线程所共享，所以会存在线程安全的问题，在方法上加入同步处理的代码synchronized，解决线程的安全问题
     * @return
     */
    public static synchronized SingleLeton04 getInstance() {
        if (instance == null) {
            instance = new SingleLeton04();
        }
        return instance;
    }
}

>>>>>总结<<<<<<：

解决了线程的安全问题，即可以在多线程的情况下使用
效率太低了，每个线程在想获得类的实例时候，执行 getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。方法进行同步效率太低

结论：

实际项目中，不推荐使用

5、懒汉式（线程安全-同步代码块）

package com.trg.designmodel.singleleton;

/**
 * @ClassName: SingleLetonTest05
 * @Description:    单例设计模式-懒汉式（线程安全-同步代码块）
 * @Author: tangrg
 * @Date: 2021/6/30 16:03
 * @Version: 1.0
 * @Return:
 **/
public class SingleLetonTest05 {
    public static void main(String[] args) {
        SingleLeton05 instance = SingleLeton05.getInstance();
        SingleLeton05 instance2 = SingleLeton05.getInstance();
        System.out.println("单例设计模式-懒汉式（线程安全-同步代码块）");
        System.out.println(instance == instance2);
        System.out.println("instance:" + instance.hashCode());
        System.out.println("instance2:" + instance2.hashCode());
    }
}

class SingleLeton05 {
    private static SingleLeton05 instance;

    private SingleLeton05() {
    }

    public static SingleLeton05 getInstance() {
        if (instance == null) {
            synchronized (SingleLeton05.class) {
                instance = new SingleLeton05();
            }
        }
        return instance;
    }


}

>>>>>总结<<<<<<：

同上面的同步方法

总结：

不推荐使用

6、双重检查（推荐使用）

package com.trg.designmodel.singleleton;

/**
 * @ClassName: SingleLetonTest06
 * @Description: 单例设计模式-懒汉式（双重检查）
 * @Author: tangrg
 * @Date: 2021/6/30 16:53
 * @Version: 1.0
 * @Return:
 **/
public class SingleLetonTest06 {

    public static void main(String[] args) {
        SingleLeton06 instance = SingleLeton06.getInstance();
        SingleLeton06 instance2 = SingleLeton06.getInstance();
        System.out.println("单例设计模式-懒汉式（双重检查）");
        System.out.println(instance == instance2);
        System.out.println("instance:" + instance.hashCode());
        System.out.println("instance2:" + instance2.hashCode());
    }
}

class SingleLeton06 {
    private static volatile SingleLeton06 instance;

    private SingleLeton06() {

    }

    //提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
    public static SingleLeton06 getInstance() {
        if (instance == null) {
            synchronized (SingleLeton06.class) {
                if (instance == null) {
                    instance = new SingleLeton06();
                }
            }
        }
        return instance;
    }
}

>>>>>总结<<<<<<：

Double-Check 概念是多线程开发中常使用到的，如代码中所示，我们进行了两次 if (singleton == null)检查，这样就可以保证线程安全了。
实例化代码只执行了一次，后面再次访问时，判断 if (singleton == null)，直接 return 实例化对象，也避免的反复进行方法同步.
线程安全；延迟加载；效率较高

总结：

实际工作中，推荐使用这种方式

7、静态内部类（推荐使用）

先要清楚一下什么是静态内部类，静态内部类有什么特点？为什么他可以作为单例设计模式

静态内部类：在类中再定义一个static开头的类，就是静态内部类

特点：

①当外部类被装载的时候，静态内部类不会被装载

②当被调用的时候才会进行装载，装载的时候只会装载一次，所以装载的时候是线程安全的

综上，通过静态内部类，可以达到懒加载的效果，同时也能保证线程安全

package com.trg.designmodel.singleleton;

/**
 * @ClassName: SingleLetonTest07
 * @Description:       单例设计模式-懒汉式（静态内部类）
 * @Author: tangrg
 * @Date: 2021/6/30 17:01
 * @Version: 1.0
 * @Return:
 **/
public class SingleLetonTest07 {

    public static void main(String[] args) {
        SingleLeton07 instance = SingleLeton07.getInstance();
        SingleLeton07 instance2 = SingleLeton07.getInstance();
        System.out.println("单例设计模式-懒汉式（静态内部类）");
        System.out.println(instance == instance2);
        System.out.println("instance:" + instance.hashCode());
        System.out.println("instance2:" + instance2.hashCode());
    }
}

class SingleLeton07{
    private SingleLeton07(){}


    //提供一个静态的内部类，该类中有一个静态属性
    public static SingleLeton07 getInstance(){
        return SingletonInstance.INSTANCE;
    }
    //写一个静态内部类,该类中有一个静态属性 Singleton
    public  static class SingletonInstance{
        private static final SingleLeton07 INSTANCE = new SingleLeton07();

    }
}

>>>>>总结<<<<<<：

这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
静态内部类方式在 Singleton 类被装载时并不会立即实例化，而是在需要实例化时，调用 getInstance 方法，才会装载 SingletonInstance 类，从而完成 Singleton 的实例化。
类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高

总结：

推荐使用

8、枚举（推荐使用）

package com.trg.designmodel.singleleton;

/**
 * @ClassName: SingleLetonTest08
 * @Description:
 * @Author: tangrg
 * @Date: 2021/6/30 17:26
 * @Version: 1.0
 * @Return:
 **/
public class SingleLetonTest08 {

    public static void main(String[] args) {
        SingleLeton08 instance = SingleLeton08.INSTANCE;
        SingleLeton08 instance2 = SingleLeton08.INSTANCE;
        System.out.println("单例设计模式-枚举");
        System.out.println(instance == instance2);
        System.out.println("instance:" + instance.hashCode());
        System.out.println("instance2:" + instance2.hashCode());
        instance2.say();

    }
}

enum  SingleLeton08{
    INSTANCE;
    public void say(){
        System.out.println("OK");
    }


}

>>>>>总结<<<<<<：

这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
这种方式是 Effective Java 作者 Josh Bloch 提倡的方式

总结：推荐使用

三、源码分析以及总结

Runtime 类使用了饿汉式的静态常量的方式

public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}
    
    /**代码省略***/
    
 }

唐小码

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式学习第一天：8种单例设计模式

一、基础概念1、什么是单例设计模式？二、单例设计模式的八种方式1、饿汉式（静态常量）（可用）2、饿汉式（静态代码块）（可用）3、懒汉式（线程不安全）4、懒汉式（线程安全-同步方法）5、懒汉式（线程安全-同步代码块）6、双重检查（推荐使用）7、静态内部类（推荐使用）8、枚举（推荐使用）一、基础概念1、什么是单例设计模式？在整个软件系统中，某个类只存在一个对象实例。且该类通过静态方法只提供一种取得实例的方法。举例：比如 Hibernat..
复制链接

扫一扫