Java并发编程中的设计模式解析(二)一个单例的七种写法-低调大师

Java并发编程中的设计模式解析(二)一个单例的七种写法

2018-11-07 559

Java单例模式是最常见的设计模式之一，广泛应用于各种框架、中间件和应用开发中。单例模式实现起来比较简单，基本是每个Java工程师都能信手拈来的，本文将结合多线程、类的加载等知识，系统地介绍一下单例模式的演变，并体现在7种不同的单例设计中。说到这个，非常像孔乙己里那个“回字有四种写法”的梗，不过与封建迂腐文人不同的是，从简单的单例设计变化，可以看到一个需求演变的过程，看到一个方法不断完善的过程。

传送门：Java并发编程中的设计模式解析(一)

1. 饿汉式

最简单的单例设计，优点是线程安全，但是因为类加载即初始化实例，加入实例变量比较多的话，会占用较多的内存。

 1 //不允许被继承
 2 public final class SingletonStarve {
 3     //实例变量, 由于单例对象是静态的, 在类的加载阶段, 就会初始化实例变量
 4     @SuppressWarnings("unused")
 5     private byte[] data = new byte[1024];
 6     //定义静态实例对象的时候直接初始化
 7     private static SingletonStarve instance = new SingletonStarve();
 8     //私有化构造函数, 不允许直接new对象
 9     private SingletonStarve() {}
10     //提供公共的方法获取实例对象
11     public static SingletonStarve getInstance() {
12         return instance;
13     }
14 }

2. 懒汉式

实现了单例设计的懒加载，节省了前期内存空间的占用，但是在多线程环境下可能会导致多对象的产生，破坏实例唯一性。

 1 //不允许被继承
 2 public final class LazySingleton {
 3     //实例变量, 由于单例对象是静态的, 在类的加载阶段, 就会初始化实例变量
 4     @SuppressWarnings("unused")
 5     private byte[] data = new byte[1024];
 6     //定义静态实例对象, 不直接初始化
 7     private static LazySingleton instance = null;
 8     //私有化构造函数, 不允许直接new对象
 9     private LazySingleton() {}
10     //提供公共的方法获取实例对象
11     public static LazySingleton getInstance() {
12         if(null == instance) {
13             instance = new LazySingleton();
14         }
15         return instance;
16     }
17 }

3. 懒汉式+同步锁

通过使用synchronized关键字使getInstance方法变为同步方法，从而确保线程安全，但带来了一定的性能问题。

 1 //不允许被继承
 2 public final class SyncLazySingleton {
 3     //实例变量, 由于单例对象是静态的, 在类的加载阶段, 就会初始化实例变量
 4     @SuppressWarnings("unused")
 5     private byte[] data = new byte[1024];
 6     //定义静态实例对象, 不直接初始化
 7     private static SyncLazySingleton instance = null;
 8     //私有化构造函数, 不允许直接new对象
 9     private SyncLazySingleton() {}
10     //提供公共的方法获取实例对象, 通过synchronized修饰为同步方法
11     public static synchronized SyncLazySingleton getInstance() {
12         if(null == instance) {
13             instance = new SyncLazySingleton();
14         }
15         return instance;
16     }
17 }

4. Double-Check

推荐使用：Double-Check单例模式，通过两次非空判断，并且对第二次判断加锁，确保了多线程下的单例设计安全，同时保证了性能。

注意：Double-check有可能因为JVM指令重排的原因，导致空指针异常；使用volatile修饰对象引用，可以确保其可见性，避免异常

 1 //不允许被继承
 2 public final class VolatileDoubleCheckSingleton {
 3     //实例变量, 由于单例对象是静态的, 在类的加载阶段, 就会初始化实例变量
 4     @SuppressWarnings("unused")
 5     private byte[] data = new byte[1024];
 6     //定义静态实例对象, 不直接初始化
 7     //通过volatile, 避免指令重排序导致的空指针异常
 8     private static volatile VolatileDoubleCheckSingleton instance = null;
 9     Connection conn;
10     Socket socket;
11     //私有化构造函数, 不允许直接new对象
12     //由于指令重排序, 实例化顺序可能重排, 从而导致空指针,使用volatile关键字修饰单例解决
13     private VolatileDoubleCheckSingleton() {
14         //this.conn;
15         //this.socket;
16     }
17     //提供公共的方法获取实例对象
18     public static VolatileDoubleCheckSingleton getInstance() {
19      20         if(null == instance) {
21             synchronized(VolatileDoubleCheckSingleton.class) {
22                 if(null == instance) {//以下赋值因为不是原子性的，如果不使用volatile使instance在多个线程中可见，将可能导致空指针
23                     instance = new VolatileDoubleCheckSingleton();                    
24                 }
25             }
26         }
27         return instance;
28     }
29 }

5. 静态内部类

推荐使用：通过使用静态内部类，巧妙地避免了线程不安全，并且节省了前期内存空间，编码非常简洁。

 1 //不允许被继承
 2 public final class HolderSingleton {
 3     //实例变量
 4     @SuppressWarnings("unused")
 5     private byte[] data = new byte[1024];
 6     //私有化构造器
 7     private HolderSingleton() {}
 8     //定义静态内部类Holder, 及内部实例成员, 并直接初始化
 9     private static class Holder{
10         private static HolderSingleton instance = new HolderSingleton();
11     }
12     //通过Holder.instance获得单例
13     public static HolderSingleton getInstance() {
14         return Holder.instance;
15     }
16 }

6. 枚举类

《Effective Java》中推荐的单例设计模式，缺点是饿汉式，并且对编码能力要求较高。

 1 //枚举本身是final的, 不允许被继承
 2 public enum EnumSingleton {
 3     INSTANCE;
 4     //实例变量
 5     @SuppressWarnings("unused")
 6     private byte[] data = new byte[1024];
 7     
 8     EnumSingleton() {
 9         System.out.println("INSTANCE will be initialized immediately");
10     }
11     public static void method() {
12         //调用该方法会主动使用EnumSingleton, INSTANCE将会实例化
13     }
14     public static EnumSingleton getInstance() {
15         return INSTANCE;
16     }
17 }

7. 内部枚举类

 1 /*
 2  * 使用枚举类作为内部类实现懒加载
 3  */
 4 public final class LazyEnumSingleton {
 5     private LazyEnumSingleton(){}
 6     private enum EnumHolder{
 7         INSTANCE;
 8         private LazyEnumSingleton instance;
 9         EnumHolder(){
10             this.instance = new LazyEnumSingleton();
11         }
12         private LazyEnumSingleton getLazyEnumSingleton() {
13             return instance;
14         }
15     }
16     public static LazyEnumSingleton getInstance() {
17         return EnumHolder.INSTANCE.getLazyEnumSingleton();
18     }
19 }

微信关注我们

原文链接：https://yq.aliyun.com/articles/669540

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

排查Java高CPU占用原因

开篇在简书看到一篇公众号讲如何排查CPU问题，想了想在日常工作中也偶尔遇到这样的问题，所以在网上搜了搜该方面的文章，特意拷贝了一篇文章作日后排查参考。整体来说是按照三步走： 1、top命令发现占用cpu最多的进程PID； 2、ps命令查看该进程下占用cpu最多的线程tid并转换为16进制； 3、jstack -l pid 保存进程堆栈并通过16进制的tid查找对应的代码块。步骤 1、top命令发现某个进程占用了100%的CPU 2、通过ps命令，进一步确定哪个进程出了问题 3、再查看线程占用CPU的列表 ps -mp PID(进程号) -o THREAD,tid,time 说明： -m Show threads after processes 4、找到占用CPU最高的线程，查看TID，将其转换为16进制格式 printf "%x\n" TID 5、而后查看堆栈信息 jstack PID |grep 16进制TID -A 60 参考排查Java高CPU占用原因

2018-11-08

604

Jersey 2.x 从Maven Archetype 创建一个新项目

创建 Jersey 工程需要使用 Apache 的Maven软件工程和管理工具。所有的Jersey产品模块都可以在Maven中央库中找到。这样的话Jersey 可以非常容易和其他基于 Maven 的项目进行配置（non-SNAPSHOT）。 Jersey 已经部署到中央仓库中了，因此你不需要配置其他仓库来让Jersey 可以工作。有关 SNAPSHOT 版本如果你想要使用最新的 Jersey 模块的 SNAPSHOT 版本（SNAPSHOT 版本代表不稳定、尚处于开发中的版本），需要在 pom.xml 中添加如下内容： <repository><id>snapshot-repository.java.net</id><name>Java.netSnapshot Repository for Maven</name><url>https://maven.java.net/content/repositories/snapshots/</url><layout>default</lay...

2018-11-08

527

发表评论

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。