AI 助理
备案控制台
开发者社区 华章出版社 文章 正文

Java多线程核心技术(五)单例模式与多线程

2019-09-21 930
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 本文只需要考虑一件事：如何使单例模式遇到多线程是安全的、正确的。

本文只需要考虑一件事：如何使单例模式遇到多线程是安全的、正确的。

1.立即加载 / "饿汉模式"

什么是立即加载？立即加载就是使用类的时候已经将对象创建完毕，常见的实现办法就是直接 new 实例化。

public class MyObject {
    private static MyObject myObject = new MyObject();

    public MyObject(){

    }

    public static MyObject getInstance(){
        return myObject;
    }


    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
    }

}

打印结果：

985396398
985396398
985396398

控制台打印的 hashCode 是同一个值，说明对象是同一个，也就实现了立即加载型单例设计模式。

此版本的缺点是不能有其他其他实例变量，因为getInstance()方法没有同步，所以有可能出现非线程安全问题。

2.延迟加载 / "懒汉模式"

什么是延迟加载？延迟加载就是在调用 get() 方法时实例才被创建，常见的实现方法就是在 get() 方法中进行 new() 实例化。

测试代码：

public class MyObject {
    private static MyObject myObject;

    public MyObject() {

    }

    public static MyObject getInstance() {
        try {
            if (myObject == null) {
                //模拟对象在创建之前做的一些准备工作
                Thread.sleep(3000);
                myObject = new MyObject();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }


    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
    }

}

打印结果：

985396398
610025186
21895028

从运行结果来看，创建了三个对象，并不是真正的单例模式。原因显而易见，3个线程同时进入了if (myObject == null) 判断语句中，最后各自都创建了对象。

3.延迟加载解决方案

3.1 声明synchronized关键字

既然多个线程可以同时进入getInstance() 方法，那么只需要对其进行同步synchronized处理即可。

public class MyObject {
    private static MyObject myObject;

    public MyObject() {

    }

    synchronized public static MyObject getInstance() {
        try {
            if (myObject == null) {
                //模拟对象在创建之前做的一些准备工作
                Thread.sleep(3000);
                myObject = new MyObject();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }


    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
    }

}

打印结果：

961745937
961745937
961745937

虽然运行结果表明，成功实现了单例，但这种给整个方法上锁的解决方法效率太低。

3.2 尝试同步 synchronized 代码块

同步方法是对方法的整体加锁，这对运行效率来讲很不利的。改成同步代码块后：

public class MyObject {
    private static MyObject myObject;

    public MyObject() {

    }

    public static MyObject getInstance() {
        try {
            synchronized (MyObject.class) {
                if (myObject == null) {
                    //模拟对象在创建之前做的一些准备工作
                    Thread.sleep(3000);
                    myObject = new MyObject();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }


    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
    }

}

打印结果：

355159803
355159803
355159803

运行结果虽然表明是正确的，但同步synchronized语句块依旧把整个 getInstance()方法代码包括在内，和synchronize 同步方法效率是一样低下。

3.3 针对某些重要的代码进行单独同步

所以，我们可以针对某些重要的代码进行单独的同步，而其他的代码则不需要同步。这样在运行时，效率完全可以得到大幅度提升。

public class MyObject {
    private static MyObject myObject;

    public MyObject() {

    }

    public static MyObject getInstance() {
        try {
            if (myObject == null) {
                //模拟对象在创建之前做的一些准备工作
                Thread.sleep(3000);
                synchronized (MyObject.class) {
                    myObject = new MyObject();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }


    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
    }

}

运行结果：

985396398
21895028
610025186

此方法只对实例化对象的关键代码进行同步，从语句的结构上来说，运行的效率的确得到的提升。但是在多线程的情况下依旧无法解决得到一个单例对象的结果。

3.4 使用DCL双检查锁机制

在最后的步骤中，使用DCL双检查锁机制来实现多线程环境中的延迟加载单例设计模式。

public class MyObject {
    private volatile static MyObject myObject;

    public MyObject() {

    }

    public static MyObject getInstance() {
        try {
            if (myObject == null) {
                //模拟对象在创建之前做的一些准备工作
                Thread.sleep(3000);
                synchronized (MyObject.class) {
                    if (myObject == null) {
                        myObject = new MyObject();
                    }
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }


    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
    }

}

运行结果：

860826410
860826410
860826410

使用DCL双重检查锁功能，成功地解决了“懒汉模式”遇到多线程的问题。DCL也是大多数多线程结合单例模式使用的解决方案。

4.使用静态内置类实现单例模式

DCL可以解决多线程单例模式的非线程安全问题。当然，还有许多其它的方法也能达到同样的效果。

public class MyObject {
    public static class  MyObjectHandle{
        private static MyObject myObject = new MyObject();
        public static MyObject getInstance() {
            return myObject;
        }
    }

    public static MyObject getInstance(){
        return MyObjectHandle.getInstance();
    }

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
    }
}

打印结果：

1035057739
1035057739
1035057739

静态内置类可以达到线程安全问题，但如果遇到序列化对象时，使用默认的方式运行得到的结果还是多例的。

解决方法就是在反序列化中使用readResolve()方法：

public class MyObject implements Serializable {
    //静态内部类
    public static class  MyObjectHandle{
        private static final MyObject myObject = new MyObject();
    }

    public static MyObject getInstance(){
        return MyObjectHandle.myObject;
    }

    protected Object readResolve(){
        System.out.println("调用了readResolve方法");
        return MyObjectHandle.myObject;
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        MyObject myObject = MyObject.getInstance();
        FileOutputStream outputStream = new FileOutputStream(new File("myObject.txt"));
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
        objectOutputStream.writeObject(myObject);
        objectOutputStream.close();
        System.out.println(myObject.hashCode());

        FileInputStream inputStream =  new FileInputStream(new File("myObject.txt"));
        ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
        MyObject object = (MyObject) objectInputStream.readObject();
        objectInputStream.close();
        System.out.println(object.hashCode());
    }
}

运行结果：

621009875
调用了readResolve方法
621009875

5.使用static代码块实现单例模式

静态代码块中的代码在使用类的时候就已经执行了，所以可以应用静态代码块的这个特点来实现单例设计模式。

public class MyObject {
    private static MyObject myObject = null;
    static {
        myObject = new MyObject();
    }
    public static MyObject getInstance(){
        return myObject;
    }
    public static void main(String[] args){
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
    }

}

运行结果：

355159803
355159803
355159803

6.使用enum枚举数据类型实现单例模式

枚举enum 和静态代码块的特性相似，在使用枚举类时，构造方法会被自动调用，也可以应用其这个特性实现单例设计模式。

public enum Singleton {
    INSTANCE;
    private MyObject myObject = null;
    Singleton() {
        myObject = new MyObject();
    }
    public MyObject getInstance(){
        return myObject;
    }

    public static void main(String[] args){
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Singleton.INSTANCE.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Singleton.INSTANCE.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Singleton.INSTANCE.getInstance().hashCode());
            }
        }).start();
    }
}

运行结果：

1516133987
1516133987
1516133987

这样实现的一个弊端就是违反了“职责单一原则”，完善后的代码如下：

public class MyObject {
    public enum Singleton {
        INSTANCE;
        private MyObject myObject = null;

        Singleton() {
            myObject = new MyObject();
        }

        public MyObject getInstance() {
            return myObject;
        }
    }

    public static MyObject getInstance(){
        return Singleton.INSTANCE.getInstance();
    }
    public static void main(String[] args){
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
    }

}

运行结果：

610025186
610025186
610025186

7.文末总结

本文使用若干案例来阐述单例模式与多线程结合遇到的情况与解决方案。

嗨，你还在看吗？

文章来源：微信公众号 薛勤的博客

文章标签：
Java
SQL
设计模式
关键词：
Java技术
Java线程
Java多线程
线程多线程
Java单例模式
初商
目录
相关文章
龙大吉
|
2月前
|
Java 开发者
在Java多线程编程中，创建线程的方法有两种：继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中，创建线程的方法有两种：继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱，帮助你更好地理解和选择适合项目需求的线程创建方式。
龙大吉
23 3
东方睿赢
|
2月前
|
Java 开发者
在Java多线程编程中，选择合适的线程创建方法至关重要
【10月更文挑战第20天】在Java多线程编程中，选择合适的线程创建方法至关重要。本文通过案例分析，探讨了继承Thread类和实现Runnable接口两种方法的优缺点及适用场景，帮助开发者做出明智的选择。
东方睿赢
20 2
东方睿赢
|
2月前
|
Java
Java中多线程编程的基本概念和创建线程的两种主要方式：继承Thread类和实现Runnable接口
【10月更文挑战第20天】《JAVA多线程深度解析：线程的创建之路》介绍了Java中多线程编程的基本概念和创建线程的两种主要方式：继承Thread类和实现Runnable接口。文章详细讲解了每种方式的实现方法、优缺点及适用场景，帮助读者更好地理解和掌握多线程编程技术，为复杂任务的高效处理奠定基础。
东方睿赢
34 2
XIAZHI
|
21天前
|
数据采集 Java Python
爬取小说资源的Python实践：从单线程到多线程的效率飞跃
本文介绍了一种使用Python从笔趣阁网站爬取小说内容的方法，并通过引入多线程技术大幅提高了下载效率。文章首先概述了环境准备，包括所需安装的库，然后详细描述了爬虫程序的设计与实现过程，包括发送HTTP请求、解析HTML文档、提取章节链接及多线程下载等步骤。最后，强调了性能优化的重要性，并提醒读者遵守相关法律法规。
XIAZHI
55 0
Lêvï
|
7月前
|
SQL Java 数据库连接
Java从入门到精通：3.1.2深入学习Java EE技术——Hibernate与MyBatis等ORM框架的掌握
Java从入门到精通：3.1.2深入学习Java EE技术——Hibernate与MyBatis等ORM框架的掌握
Lêvï
78 1
Lêvï
|
7月前
|
存储 设计模式 算法
Java从入门到精通：2.1.1深入学习Java核心技术——掌握Java集合框架
Java从入门到精通：2.1.1深入学习Java核心技术——掌握Java集合框架
Lêvï
50 0
洛神灬殇
|
7月前
|
算法 Java 程序员
论文翻译 | 【深入挖掘Java技术】「底层原理专题」深入分析一下并发编程之父Doug Lea的纽约州立大学的ForkJoin框架的本质和原理
本文深入探讨了一个Java框架的设计、实现及其性能。该框架遵循并行编程的理念，通过递归方式将问题分解为多个子任务，并利用工作窃取技术进行并行处理。所有子任务完成后，其结果被整合以形成完整的并行程序。 在总体设计上，该框架借鉴了Cilk工作窃取框架的核心理念。其核心技术主要聚焦于高效的任务队列构建和管理，以及工作线程的管理。经过实际性能测试，我们发现大多数程序的并行加速效果显著，但仍有优化空间，未来可能需要进一步研究改进方案。
洛神灬殇
87 3
论文翻译 | 【深入挖掘Java技术】「底层原理专题」深入分析一下并发编程之父Doug Lea的纽约州立大学的ForkJoin框架的本质和原理
洛神灬殇
|
7月前
|
XML Java 测试技术
【Java技术专题】「核心技术提升」最流行的Java模拟框架Mockito入门指南（Java单元测试）
【Java技术专题】「核心技术提升」最流行的Java模拟框架Mockito入门指南（Java单元测试）
洛神灬殇
84 0
洛神灬殇
|
7月前
|
Java 测试技术 API
【Java技术深入解析】「核心技术提升」最流行的Java模拟框架Mockito入门指南（Java单元测试）
还在使用 Mockito 1.x？看看 Mockito 2 有哪些新功能！Mockito 3 没有引入任何破坏性的 API 变动，但现在需要 Java 8 而不是 Mockito 2 的 Java 6。 Mockito 4 删除了过时的 API。Mockito 5 将默认 mockmaker 改为 mockito-inline，现在需要 Java 11。一次只支持一个主要版本，而且不会向旧版本回传更改内容。
洛神灬殇
148 0
【Java技术深入解析】「核心技术提升」最流行的Java模拟框架Mockito入门指南（Java单元测试）
翰文编程
|
SQL 前端开发 Java
JSP个人信息管理系统myeclipse开发sql数据库BS模式java编程struts2技术mvc框架
JSP 个人信息管理系统是一套完善的web设计系统，对理解JSP java编程开发语言有帮助struts2技术mvc框架，系统具有完整的源代码和数据库，开发环境为TOMCAT7.0,Myeclipse8.5开发，数据库为Mysql5.0，使用java语言开发,系统主要采用B/S模式开发。
翰文编程
95 0

华章出版社

热门文章

最新文章

  • 1
    【Java】留下没有基础眼泪的面试题
  • 2
    阿里巴巴Java开发规约-插件使用[Idea和Eclipse]
  • 3
    关于Java面向对象的分析题
  • 4
    代码行数减少 30-90%！多邻国从Java迁移到Kotlin的奇妙体验
  • 5
    漫谈 Java 实例化类
  • 6
    《连载 | 物联网框架ServerSuperIO教程》1.4种通讯模式机制。附小文：招.NET开发，结果他转JAVA了，一切都是为了生活
  • 7
    java-subString方法易导致内存溢出
  • 8
    离开了IDEA，你还会运行JAVA项目吗？
  • 9
    Java-学习笔记-8-接口
  • 10
    Java Poi 创建与读取Excel
  • 1
    FFmpeg开发笔记（十九）FFmpeg开启两个线程分别解码音视频
    120
  • 2
    实时计算 Flink版产品使用合集之全量快照是由多个线程同时进行的吗
    35
  • 3
    Android插件化探索与发现，kotlin协程切换线程
    39
  • 4
    python多线程中：如何关闭线程？
    134
  • 5
    Android 笔记：AndroidTrain , Lint , build(1)，只需一篇文章吃透Android多线程技术
    58
  • 6
    Python的多线程允许在同一进程中并发执行任务
    74
  • 7
    实时计算 Flink版产品使用合集之mysql通过flink cdc同步数据，有没有办法所有表共用一个dump线程
    51
  • 8
    Android中的多线程及AsyncTask的引入，最终入职阿里
    61
  • 9
    神经网络基本概念以及Pytorch实现，多线程编程面试题
    88
  • 10
    阅读《代码整洁之道》总结(1)，java多线程面试
    46

    • 相关课程

    更多
  • Java面向对象开发
  • 5天玩转Java面向对象编程
  • Java面向对象编程
  • Java面试疑难点解析 - 系统架构及项目设计
  • 「大师课」搞定 Java 开发基础
  • Java编程入门

    • 相关电子书

    更多
  • 多IO线程优化版
  • JAVA反射原理以及一些常见的应用
  • 阿里特邀专家关键：Java无锁集合代码分析

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    阿里云对象存储OSS收费标准：存储、流量和请求等多个计费项详解