Head First Design Patterns——单例模式

其他 2020-04-09 18:02:17 阅读次数: 0

文章目录

单例模式：也叫单件模式，可以用来创建独一无二的，只能有一个实例的对象，并且该类只提供一个取得其对象实例的方法(static)！它是所有设计模式中最简单的，它的类图只有一个类：

1）饿汉式（静态常量）

创建的步骤：
1.构造器私有化（防止 new来获得实例）
2.类的内部创建对象
3.向外界暴露一个静态的公共方法。getInstance
4.代码实现

//饿汉式（静态变量)
class Singleton{

    //1.构造器私有化
    private Singleton(){

    }

    //2.本类内部创建对象实例
    private final static Singleton instance = new Singleton();

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

public class Singleton1 {
    public static void main(String[] args) {

        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();

        System.out.println("instance:"+instance.hashCode()+"\n"+"instance1:"+instance1.hashCode());
    }
}
  • 测试结果
    在这里插入图片描述
    两个对象实例的hashCode值相等，说明 new的两个对象是同一个，这样就避免了new实例多个对象！
  • 优缺点：

优点：这种写法比较简单，就是在类装载的时候就完成 了实例化，避免了线程同步问题。
缺点：
1.在类装载时就完成 了实例化，油源有达到Lazy Loading的效果，如果从始至终从未使用过这个实例，则会造成内存的浪费。
2.这种方式基于classLoader机制避免了多线程的同步问题，不过，Instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式导致类装载，这时候初始化instance就没有达到Lazy Loading的效果。

  • 结论：

这种单例模式可用，可能会造成内存浪费！

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

这和方式和静态常量方法类似 ，只是在内部将创建实例对象的操作放到了静态代码块中进行了

  • 代码实现
//饿汉式（静态代码块）

class Singleton{

    //1.构造器私有化
    private Singleton(){

    }

    //2.本类内部创建对象实例
    private final static Singleton instance;

    static {//在静态代码块中创建单例对象
        instance = new Singleton();
    }

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

public class Singleton2 {
    public static void main(String[] args) {

        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();

        System.out.println("instance:"+instance.hashCode()+"\n"+"instance1:"+instance1.hashCode());
    }
}
  • 运行结果
    在这里插入图片描述
  • 结论：

这种单例模式也是可用的，但是可能会造成内存浪费

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

  • 代码实现
public class SingletonTest03 {
    public static void main(String[] args) {

        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance == instance1);
        System.out.println("instance:"+instance.hashCode()+"\n"+"instance1:"+instance1.hashCode());
    }
}


class Singleton{
    private static Singleton instance;

    private Singleton(){}

    //提供一个静态的公有方法，使用到该方法时，才去创建instance
    public static Singleton getInstance(){
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
  • 运行结果
    在这里插入图片描述
  • 总结：

提供一个静态的公有方法，使用到该方法时，才去创建instance
1.起到了Lazy Loading的效果，但是只能在单线程下使用
2.如果在多线程下，一个线程进入了if(singleton == null)判断语句时，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式

  • 结论：

在实际开发中，不要使用这种方式。

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

  • 代码实现
public class SingletonTest04 {
    public static void main(String[] args) {

        System.out.println("懒汉式（线程安全，同步方法）");
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance == instance1);
        System.out.println("instance:"+instance.hashCode()+"\n"+"instance1:"+instance1.hashCode());
    }
}

//懒汉式（线程安全，同步方法）
class Singleton{
    private static Singleton instance;

    private Singleton(){}

    //提供一个静态的公有方法,加入同步处理的代码，解决线程安全问题
    //synchronized
    public static synchronized Singleton getInstance(){
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
  • 运行结果
    在这里插入图片描述
  • 总结：
  1. 解决了线程不安全问题
  2. 效率太低了，每个线程都在想获得类的实例时候，执行getInstance()方法都要进行执行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该实例，直接return 就行了，方法进行同步的效率太低了。
  • 总结
    在实际开发中，不推荐使用这种方式

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

public class SingletonTest05 {
    public static void main(String[] args) {

        System.out.println("懒汉式 同步代码块");
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance == instance1);
        System.out.println("instance:"+instance.hashCode()+"\n"+"instance1:"+instance1.hashCode());
    }
}

//懒汉式（线程安全，同步方法）
class Singleton{

    private static  Singleton instance;

    private Singleton(){}

    //提供一个静态的公有方法,加入同步处理的代码，解决线程安全问题
    //synchronized
    public static  Singleton getInstance(){
        if (instance == null) {
            synchronized (Singleton.class) {
                instance = new Singleton();
            }
        }
        return instance;
    }
}
  • 运行结果
    在这里插入图片描述
  • 总结：
  1. 这种方式，本意是想对第四种方式的改进，因为前面同步方法效率太低了，改为同步 产生实例化的代码块。
  2. 但是这种同步并不能起到线程同步的作用。，假如一个线程进入到if(Singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。
  • 结论：
    在实际开发中，不能使用这种方式。

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

  • 代码实现
public class SingletonTest06 {
    public static void main(String[] args) {

        System.out.println("双重检查");
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance == instance1);
        System.out.println("instance:"+instance.hashCode()+"\n"+"instance1:"+instance1.hashCode());
    }
}

//懒汉式（线程安全，同步方法）
class Singleton{

    private static volatile Singleton instance;

    private Singleton(){}

    //提供一个静态的公有方法,加入双重检查代码，解决线程安全问题，同时解决懒加载问题
    //同时保证了效率
    public static Singleton getInstance(){
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
  • 运行结果
    在这里插入图片描述
  • 总结
  1. Double-Check概念是多线程开发中学使用到的，我们进行了两次if (instance == null)检查，这样就可以保证线程安全了
  2. 这样，实例化代码只执行一次，后面再次访问时，判断if (instance == null)，直接 return实例化对象，也就避免了反复执行方法同步 。
  3. 线程安全，延迟加载，效率较高
  • 结论：
    在开发中，推荐使用这种单例设计模式!

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

基本介绍：

  1. 静态内部类不会在类装载时，直接执行，保证了懒加载
  2. 在调用类中的方法时，再装载静态内部类，是可行的，JVM中进行类装载时是线程安全的
  • 代码实现
public class SingletonTest7 {
    public static void main(String[] args) {

        System.out.println("静态内部类：单例模式");
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance == instance1);
        System.out.println("instance:"+instance.hashCode()+"\n"+"instance1:"+instance1.hashCode());
    }
}

//静态内部类
class Singleton{

    private static volatile Singleton instance;

    private Singleton(){}

    //静态内部类
    private static class SingletonInstance{
        private static final Singleton INSTANCE = new Singleton();
    }

    //提供一个静态的公有方法,直接返回SingletonInstance.INSTANCE
    public static Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }
}
  • 运行结果
    在这里插入图片描述
  • 总结

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

  • 结论
    推荐使用！

8）枚举方式

  • 代码实现
public class SingletonTest08 {
    public static void main(String[] args) {

        Singleton instance = Singleton.INSTANCE;
        Singleton instance1 = Singleton.INSTANCE;
        System.out.println(instance == instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());

        instance.sayHello();
    }
}

//使用枚举可以实现单例，推荐作用
enum Singleton{
    INSTANCE;
    public void sayHello(){
        System.out.println("hello enum");
    }
}
  • 运行结果
    在这里插入图片描述
  • 总结：

1.借助JDK1.5中添加的枚举来实现单例模式，不仅可以避免多线程同步 问题，而且还能防止反序列化重新创建新的对象

  • 结论：
    强力推荐使用！！！

在这里插入图片描述

整理不易，如果大家觉得好的话，可以加关注，后续会整理更多的知识点！

Cloverd
发布了47 篇原创文章 · 获赞 34 · 访问量 8857
私信 关注

猜你喜欢

转载自blog.csdn.net/weixin_42893085/article/details/105406392
今日推荐
Linus “吃狗粮”最积极！
开源日报 | Winamp播放器即将开源；生成式AI之战升级第二轮；Linus“吃狗粮”最积极；AI进入泡沫前期；吴泳铭为阿里云带来了什么？
NetBSD 禁止提交由 AI 生成的代码
Apache Doris 2.0.10 版本正式发布！
开源日报 | 大模型开战；大模型独角兽被曝卖身；周鸿祎建议谷歌开源所有产品；最大开源AI社区提供1000万美元共享GPU
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
周排行
SVN服务端安装在阿里云
实战 | 相机标定
webpack核心概念
note20——》只要肯低头吃苦，人生就会有救
PAT甲级 1062 Talent and Virtue （25 分）排序
NG Toolset开发笔记--5GNR Resource Grid（26）
如何对待上司
oracle命令
第9章 STL迭代器
logstash使用es映射模板
每日归档
更多
2024-05-20(36)
2024-05-19(0)
2024-05-18(4)
2024-05-17(34)
2024-05-16(6)
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022