Java单例模式的8种写法(推荐)

单例:Singleton,是指仅仅被实例化一次的类。

饿汉单例设计模式

一、饿汉设计模式

public class SingletonHungry {
 private final static SingletonHungry INSTANCE = new SingletonHungry();

 private SingletonHungry() {
 }

 public static SingletonHungry getInstance() {
 return INSTANCE;
 }
}

因为单例对象一开始就初始化了,不会出现线程安全的问题。

PS:因为我们只需要初始化1次,所以给INSTANCE加了final关键字,表明初始化1次后不再允许初始化。

懒汉单例设计模式

二、简单懒汉设计模式

由于饿汉模式一开始就初始化好了,但如果一直没有被使用到的话,是会浪费珍贵的内存资源的,所以引出了懒汉模式。

懒汉:首次使用时才会去实例化对象。

public class SingletonLazy1 {
 private static SingletonLazy1 instance;

 private SingletonLazy1() {
 }

 public static SingletonLazy1 getInstance() {
 if (instance == null) {
  instance = new SingletonLazy1();
 }
 return instance;
 }
}

测试:

public class Main {
 public static void main(String[] args) {
 SingletonLazy1 instance1 = SingletonLazy1.getInstance();
 SingletonLazy1 instance2 = SingletonLazy1.getInstance();
 System.out.println(instance1);
 System.out.println(instance2);
 }
}

测试结果:从结果可以看出,打印出来的两个实例对象地址是一样的,所以认为是只创建了一个对象。

三、进阶

1:解决多线程并发问题

上述代码存在的问题:在多线程环境下,不能保证只创建一个实例,我们进行问题的重现:

public class Main {
 public static void main(String[] args) {
 new Thread(()-> System.out.println(SingletonLazy1.getInstance())).start();
 new Thread(()-> System.out.println(SingletonLazy1.getInstance())).start();
 }
}

结果:获取到的对象不一样,这并不是我们的预期结果。

解决方案:

public class SingletonLazy2 {
 private static SingletonLazy2 instance;

 private SingletonLazy2() {
 }
 //在方法加synchronized修饰符
 public static synchronized SingletonLazy2 getInstance() {
 if (instance == null) {
  instance = new SingletonLazy2();
 }
 return instance;
 }
}

测试:

public class Main2 {
 public static void main(String[] args) {
 new Thread(()-> System.out.println(SingletonLazy2.getInstance())).start();
 new Thread(()-> System.out.println(SingletonLazy2.getInstance())).start();
 new Thread(()-> System.out.println(SingletonLazy2.getInstance())).start();
 new Thread(()-> System.out.println(SingletonLazy2.getInstance())).start();
 }
}

结果:多线程环境下获取到的是同个对象。

四、进阶2:缩小方法锁粒度

上一方案虽然解决了多线程问题,但由于synchronized关键字是加在方法上的,锁粒度很大,当有上万甚至更多的线程同时访问时,都被拦在了方法外,大大降低了程序性能,所以我们要适当缩小锁粒度,控制锁的范围在代码块上。

public class SingletonLazy3 {
 private static SingletonLazy3 instance;

 private SingletonLazy3() {
 }

 public static SingletonLazy3 getInstance() {
 //代码块1:不要在if外加锁,不然和锁方法没什么区别
 if (instance == null) {
  //代码块2:加锁,将方法锁改为锁代码块
  synchronized (SingletonLazy3.class) {
  //代码块3
  instance = new SingletonLazy3();
  }
 }
 return instance;
 }
}

测试:

public class Main3 {
 public static void main(String[] args) {
 new Thread(()-> System.out.println(SingletonLazy3.getInstance())).start();
 new Thread(()-> System.out.println(SingletonLazy3.getInstance())).start();
 new Thread(()-> System.out.println(SingletonLazy3.getInstance())).start();
 new Thread(()-> System.out.println(SingletonLazy3.getInstance())).start();
 }
}

我们看一下运行结果:还是出现了线程安全的问题(每次执行都可能打印不同的地址情况,只要证明是非线程安全的即可)。

原因分析:当线程A拿到锁进入到代码块3并且还没有创建完实例时,线程B是有机会到达代码块2的,此时线程C和D可能在代码块1,当线程A执行完之后释放锁并返回对象1,线程B进入进入代码块3,又创建了新的对象2覆盖对象1并返回,最后当线程C和D在进行判null时发现instance非空,直接返回最后创建的对象2。

五、进阶3:双重检查锁DCL(Double-Checked-Locking)

所谓双重检查锁,就是在线程获取到锁之后再对实例进行第2次判空检查,判断是不是有上一个线程已经进行了实例化,有的话直接返回即可,否则进行实例初始化。

public class SingletonLazy4DCL {
 private static SingletonLazy4DCL instance;

 private SingletonLazy4DCL() {
 }

 public static SingletonLazy4DCL getInstance() {
 //代码块1:第一次判空检查
 if (instance == null) {
  //代码块2:加锁,将方法锁改为锁代码块
  synchronized (SingletonLazy3.class) {
  //代码块3:进行第二次(双重)判空检查
  if (instance == null) {
   instance = new SingletonLazy4DCL();
  }
  }
 }
 return instance;
 }
}

测试:

public class Main4DCL {
 public static void main(String[] args) {
 new Thread(()-> System.out.println(SingletonLazy4DCL.getInstance())).start();
 new Thread(()-> System.out.println(SingletonLazy4DCL.getInstance())).start();
 new Thread(()-> System.out.println(SingletonLazy4DCL.getInstance())).start();
 new Thread(()-> System.out.println(SingletonLazy4DCL.getInstance())).start();
 }
}

六、进阶4:禁止指令重排

在对象的实例过程中,大概可分为以下3个步骤:

  1. 分配对象内存空间
  2. 在空间中创建对象
  3. 实例指向分配到的内存空间地址

由于实例化对象的过程不是原子性的,且JVM本身对Java代码指令有重排的操作,可能1-2-3的操作被重新排序成了1-3-2,这样就会导致在3执行完之后还没来得及创建对象时,其他线程先读取到了未初始化的对象instance并提前返回,在使用的时候会出现NPE空指针异常。

解决:给instance加volatile关键字表明禁止指令重排,出现的概率不大, 但这是更安全的一种做法。

public class SingletonLazy5Volatile {
 //加volatile关键字
 private volatile static SingletonLazy5Volatile instance;

 private SingletonLazy5Volatile() {
 }

 public static SingletonLazy5Volatile getInstance() {
 //代码块1
 if (instance == null) {
  //代码块2:加锁,将方法锁改为锁代码块
  synchronized (SingletonLazy3.class) {
  //代码块3
  if (instance == null) {
   instance = new SingletonLazy5Volatile();
  }
  }
 }
 return instance;
 }
}

七、进阶5:静态内部类

我们还可以使用静态类的静态变量被第一次访问时才会进行初始化的特性来进行懒加载初始化。把外部类的单例对象放到静态内部类的静态成员变量里进行初始化。

public class SingletonLazy6InnerStaticClass {
 private SingletonLazy6InnerStaticClass() {
 }

 public static SingletonLazy6InnerStaticClass getInstance() {
 return SingletonLazy6InnerStaticClass.InnerStaticClass.instance;
 //或者写成return InnerStaticClass.instance;
 }

 private static class InnerStaticClass {
 private static final SingletonLazy6InnerStaticClass instance = new SingletonLazy6InnerStaticClass();
 }
}

虽然静态内部类里的写法和饿汉模式很像,但它却不是在外部类加载时就初始化了,而是在第一次被访问到时才会进行初始化的操作(即getInstance方法被调用时),也就起到了懒加载的效果,并且它可以保证线程安全。

测试:

public class Main6InnerStatic {
 public static void main(String[] args) {
 new Thread(()-> System.out.println(SingletonLazy6InnerStaticClass.getInstance())).start();
 new Thread(()-> System.out.println(SingletonLazy6InnerStaticClass.getInstance())).start();
 new Thread(()-> System.out.println(SingletonLazy6InnerStaticClass.getInstance())).start();
 new Thread(()-> System.out.println(SingletonLazy6InnerStaticClass.getInstance())).start();
 }
}

反射攻击

虽然我们一开始都对构造器进行了私有化处理,但Java本身的反射机制却还是可以将private访问权限改为可访问,依旧可以创建出新的实例对象,这里以饿汉模式举例说明:

public class MainReflectAttack {
 public static void main(String[] args) {
 try {
  SingletonHungry normal1 = SingletonHungry.getInstance();
  SingletonHungry normal2 = SingletonHungry.getInstance();
  //开始反射创建实例
  Constructor<SingletonHungry> reflect = SingletonHungry.class.getDeclaredConstructor(null);
  reflect.setAccessible(true);
  SingletonHungry attack = reflect.newInstance();

  System.out.println("正常静态方法调用获取到的对象:");
  System.out.println(normal1);
  System.out.println(normal2);
  System.out.println("反射获取到的对象:");
  System.out.println(attack);
 } catch (Exception e) {
  e.printStackTrace();
 }
 }
}

八、枚举单例(推荐使用)

public enum SingletonEnum {
 INSTANCE;
}

枚举是最简洁、线程安全、不会被反射创建实例的单例实现,《Effective Java》中也表明了这种写法是最佳的单例实现模式。

单元素的枚举类型经常成为实现Singleton的最佳方法。 --《Effective Java》

为什么说不会被反射创建对象呢?查阅构造器反射实例化对象方法newInstance的源码可知:反射禁止了枚举对象的实例化,也就防止了反射攻击,不用自己在构造器实现复杂的重复实例化逻辑了。

测试:

public class MainEnum {
 public static void main(String[] args) {
 SingletonEnum instance1 = SingletonEnum.INSTANCE;
 SingletonEnum instance2 = SingletonEnum.INSTANCE;
 System.out.println(instance1.hashCode());
 System.out.println(instance2.hashCode());
 }
}

总结:几种实现方式的优缺点 懒汉模式

优点:节省内存。

缺点:存在线程安全问题,若要保证线程安全,则写法复杂。

饿汉模式

优点:线程安全。

缺点:如果单例对象一直没被使用,则会浪费内存空间。

静态内部类

优点:懒加载并避免了多线程问题,写法相比于懒汉模式更简单。

缺点:需要多创建一个内部类。

枚举

优点:简洁、天生线程安全、不可反射创建实例。

缺点:暂无

到此这篇关于Java单例模式的8种写法的文章就介绍到这了,更多相关Java单例模式内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java单例模式实现静态内部类方法示例

    Singleton是众多设计模式中最容易理解的一种,也是众多设计模式中较为重要的一种设计模式.接下来我们看看具体介绍. Singleton模式实现的重点在于将构造函数私有化(private),并通过提供静态公有函数(public synchronized static xxx getInstance)来获取定义在类中的静态私有成员(private static xxx instance),通过一个简单的判断静态实例是否为空来控制这个类只能够new一次,即控制了一个类只能有单个实例,一般的实现如下

  • Java单例模式下的MongoDB数据库操作工具类

    本文实例讲述了Java单例模式下的MongoDB数据库操作工具类.分享给大家供大家参考,具体如下: 我经常对MongoDB进行一些基础操作,将这些常用操作合并到一个工具类中,方便自己开发使用. 没用Spring Data.Morphia等框架是为了减少学习.维护成本,另外自己直接JDBC方式的话可以更灵活,为自己以后的积累留一个脚印. JAVA驱动版本: <!-- MongoDB驱动 --> <dependency> <groupId>org.mongodb</g

  • 23种设计模式(1) java单例模式

    23种设计模式第四篇:java单例模式 定义: 单例模式,是一种常用的软件设计模式.在它的核心结构中只包含一个被称为单例的特殊类.通过单例模式可以保证系统中一个类只有一个实例.即一个类只有一个对象实例. 特点: 1.单例类只能有一个实例. 2.单例类必须自己自己创建自己的唯一实例. 3.单例类必须给所有其他对象提供这一实例 单例模式的要点: 1.私有的构造方法     2.指向自己实例的私有静态引用     3.以自己实例为返回值的静态的公有的方法 单例模式根据实例化对象时机的不同分为两种: 一

  • java 单例模式(饿汉模式与懒汉模式)

    java 单例模式 饿汉式单例 对于饿汉模式,我们可这样理解:该单例类非常饿,迫切需要吃东西,所以它在类加载的时候就立即创建对象. 懒汉式单例类 对于懒汉模式,我们可以这样理解:该单例类非常懒,只有在自身需要的时候才会行动,从来不知道及早做好准备.它在需要对象的时候,才判断是否已有对象,如果没有就立即创建一个对象,然后返回,如果已有对象就不再创建,立即返回. 单例设计模式常用于JDBC链接数据库 注意: 1 我们常用的是第一种饿汉式,因为: (1)既然采用了单例设计模式,就是为了使用单例类的对象

  • Java单例模式的8种写法(推荐)

    单例:Singleton,是指仅仅被实例化一次的类. 饿汉单例设计模式 一.饿汉设计模式 public class SingletonHungry { private final static SingletonHungry INSTANCE = new SingletonHungry(); private SingletonHungry() { } public static SingletonHungry getInstance() { return INSTANCE; } } 因为单例对象

  • Java单例模式的几种常见写法

    目录 1.饿汉模式 2.懒汉模式 3.静态内部类 4.枚举 总结 1.饿汉模式 饿汉模式也叫预加载模式,它是在类加载时直接创建并初始化单例对象,所以它并不存在线程安全的问题.它是依靠 ClassLoader 类机制,在程序启动时只加载一次,因此不存在线程安全问题,它的实现代码如下: public class Singleton { // 1.防止外部直接 new 对象破坏单例模式 private Singleton() {} // 2.通过私有变量保存单例对象 private static Si

  • Java中单例模式的七种写法示例

    目录 前言 1.饿汉式(线程安全)⭐ 2.懒汉式(线程不安全)⭐ 3.懒汉式(加锁) 4.懒汉式(双重校验锁)⭐ 5.单例模式(静态内部类) 6.单例模式(CAS) 7.单例模式(枚举) 总结 前言 大家好,我是三乙己.考上大家一考:"单例模式的单例,怎样写的?" "不就是构造方法私有化么?" "对呀对呀!--单例模式有七种写法,你知道么?" 言归正传-- 单例模式(Singleton Pattern)可以说是最简单的设计模式了. 用一个成语来形

  • 简单总结单例模式的4种写法

    一.单例模式 属于创建者模式的一种, 单例模式的目的是使该类只有一个实例,同一个类的不同对象有不同的hashCode() 单例模式是由该类自行创建唯一个向外暴露的全局的对象 二.写法 饿汉式:无线程安全,但是类以加载就会创建实例,浪费资源 懒汉式:存在线程安全,需要加synchroined 内部类:无线程安全(完美方案) 枚举: 线程安全,听说是高效java推荐的写法 三.饿汉式 /** * 饿汉式: * 不适用new创建对象而是使用静态的getInstance()方法创建对象 * jvm保证线

  • Java单例模式的6种实现方式详解

    目录 为什么使用单例模式 使用单例模式需要注意的关键点 单例模式的几种写法 1. 饿汉式 2. 懒汉式 3. DCL(Double CheckLock)实现单例 4. 静态内部类 5. 枚举单例 6. 容器实现单例 总结 为什么使用单例模式 需要确保某个类只要一个对象,或创建一个类需要消耗的资源过多,如访问IO和数据库操作等,这时就需要考虑使用单例模式了. 使用单例模式需要注意的关键点 将构造函数访问修饰符设置为private 通过一个静态方法或者枚举返回单例类对象 确保单例类的对象有且只有

  • Java for循环几种写法整理

    Java for循环几种写法整理 概要: J2SE 1.5提供了另一种形式的for循环.借助这种形式的for循环,可以用更简单地方式来遍历数组和Collection等类型的对象.本文介绍使用这种循环的具体方式,说明如何自行定义能被这样遍历的类,并解释和这一机制的一些常见问题. 在Java程序中,要"逐一处理"――或者说,"遍历"――某一个数组或Collection中的元素的时候,一般会使用一个for循环来实现(当然,用其它种类的循环也不是不可以,只是不知道是因为fo

  • js自调用匿名函数的三种写法(推荐)

    第一种: (function(){ console.log('hello world") })() 第二种: (function(){ console.log('hello world') }())  第三种: !function(){ console.log('hello world') }() 以上这篇js自调用匿名函数的三种写法(推荐)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们.

  • Java单例模式的五种实现方式

    目录 前言 饿汉单例 懒汉单例 非线程安全的懒汉单例 加同步锁的懒汉单例 双重检验懒汉单例 静态内部类 静态内部类为什么是线程安全 总结 前言 单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一.这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式. 这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建.这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象. 饿汉单例 是否多线程安全:是 是否懒加载:否

  • Python实现单例模式的五种写法总结

    目录 使用模块 使用装饰器 基于 __new__ 方法实现 基于 metaclass 方式实现 单例模式(Singleton Pattern) 是一种常用的软件设计模式,该模式的主要目的是确保某一个类只有一个实例存在.当你希望在整个系统中,某个类只能出现一个实例时,单例对象就能派上用场. 比如,某个服务器程序的配置信息存放在一个文件中,客户端通过一个 AppConfig 的类来读取配置文件的信息.如果在程序运行期间,有很多地方都需要使用配置文件的内容,也就是说,很多地方都需要创建 AppConf

  • Java中单例模式的7种写法

    第一种(懒汉,线程不安全): public class Singleton { private static Singleton instance; private Singleton (){} public static Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } } 这种写法lazy loading很明显,但是致命的是在多线程不能正常工作.

随机推荐