热门标签 | HotTags
当前位置:  开发笔记 > 编程语言 > 正文

单例模式深入浅出详细注释

1、单例模式1.1、单例设计模式它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建,这个类提供了一种访问其唯一的对象的方




1、单例模式

1.1、单例设计模式

它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建,这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象

数据库连接池就使用到了单例模式,初始化的时候创建譬如100个connection对象,然后再需要的时候
提供一个,用过之后返回到pool中,我们用单例模式,是保证连接池有且只有一个。不仅避免了实例的
重复创建,节约了内存,
使用线程池来管理线程,使用线程池来管理线程的好处是线程池中的线程可以复用,在一个线程使用过
时候,再返回到线程池中,不需要每次都创建一个线程。由于线程池是公共的,因此我们使用单例模式
来保证线程池有且仅有一个。

单例模式的优点:


  • 控制资源的使用,通过线程同步来控制资源的并发访问;
  • 控制实例产生的数量,达到节约资源的目的;
  • 作为通信媒介使用,也就是数据共享,它可以在不建立直接关联的条件下,让多个不相关的线程或者进程之间实现通信

    1.1.2、单例模式的实现

单例设计模式分两类:


  • 饿汉式:类加载就会导致该单例对象被创建
  • 懒汉式:类加载不会导致该单实例对象被创建,而是首次使用该对象时才会创建

1、饿汉式----方式1(静态变量方式)

package com.njust.singleton.hungryman_staticvar;
/**
* @program: ruoyi
* @description:单例模式----饿汉式1-----静态成员变量法
* @author: tjj
* @create: 2021-09-24 18:55
**/
//类加载到内存后,就实例化一个单例,JVM保证线程安全
//缺点:无论是否用到,类加载时就完成实例化
public class SingletonStaticVar {
// 1.私有构造方法 --------- 为什么私有构造方法 ----> 当私有构造方法以后,外界就访问不到这个构造方法
private SingletonStaticVar() { }
//外界访问不到之后,就一个方法都创建不了------> 那如何实例化对象呢 -----> 自己在该类中创建一个该类的对象,供外界使用
// 2.在本类中创建该类对象, ------> 因为只能创建一次,所以用static修饰
private static SingletonStaticVar singletOnStaticVar= new SingletonStaticVar();
// 3.提供一个公共的访问方式,让外界去访问该对象------>getInstance是可以换名字的,不过是一个返回对象的方法----
// 不过最好用getInstance,业界都这样写
public static SingletonStaticVar getInstance(){
return singletonStaticVar;
}
/*
* 其他的业务方法,无所谓,随便加
* */
public void printM() {
System.out.println("M");
}
public void printQ() {
System.out.println("Q");
}

}

public class Client {
public static void main(String[] args) {
//创建singleton类的对象
SingletonStaticVar instance = SingletonStaticVar.getInstance();
System.out.println("创建的实例对象是:"+instance);
SingletonStaticVar instance2 = SingletonStaticVar.getInstance();
System.out.println("创建的实例对象2是:"+instance2);
//判断创建的两个对象是不是同一个对象 == 判断的是两个对象的 内存地址 是否一样
System.out.println(instance == instance2);
/*
* 然后就可以调用该类的方法了
* */
instance.printM();
instance2.printQ();
}
}

2.饿汉式----方式2-----(静态代码块)

public class SingletonStaticBlock {
//1.私有构造方法
private SingletonStaticBlock() {}
//2.声明SingletonStaticBlock类型的变量------>初始值为null
private static SingletonStaticBlock singletonStaticBlock;
//3.在静态代码块中赋值
static {
singletOnStaticBlock= new SingletonStaticBlock();
}
//4.对外提供一个获取该类对象的方法,自然也就是public
public static SingletonStaticBlock getInstance(){
return singletonStaticBlock;
}

/*
* 其他的业务方法,无所谓,随便加
* */
public void printM() {
System.out.println("M");
}
public void printQ() {
System.out.println("Q");
}
}

3.懒汉式

public class SingleLazyman {
//私有构造方法
private SingleLazyman() {}
//声明单例类型的变量---->只是声明了该类型的变量,并没有进行赋值--->null
private static SingleLazyman singleLazyman;
//对外提供访问方式 当多线程的时候,可能存在线程安全的问题
public static synchronized SingleLazyman getInstance() {
//懒汉式和饿汉式的区别--->懒汉式是首次使用该类的对象的时候,才会被创建---->为了只创建一次---->所以判断该类对象是否被创建了
//如果该类为null,那么便是第一次,创建(static很关键)
if( singleLazyman == null){
singleLazyman = new SingleLazyman();
return singleLazyman;
}
//如果已经创建了该类,那么便 不再创建,
return singleLazyman;
}
/*
* 该类的一些方法
* */
public void printM() {
System.out.println("M");
}
public void printA() {
System.out.println("A");
}
}

4.懒汉式-双重检查锁

讨论:懒汉模式加锁的问题

对于getInstance()方法来说,绝大部分的操作都是读操作,读操作是线程安全的,所以我们没有必要让每个线程必须持有锁才能调用该方法,我们需要调整加锁的时机========》由此产生了一种新的实现模式:双重检查锁!!!!!

package com.njust.singleton.lazyman_double_check_lock;
/**
* @program: ruoyi
* @description: 单例模式-----懒汉式-----双重检查锁方式
* @author: tjj
* @create: 2021-09-24 20:57
**/
//双重检查锁是一种很好的单例模式,解决了单例,性能,线程安全的问题
//存在问题:在多线程情况下,可能会出现空指针异常的问题--->原因:JVM在实例化对象的时候会进行优化和指令重排序操作
// ------->解决,使用volatile关键字!!!
public class SingleLazymanDoubleLock {
//私有构造方法
private SingleLazymanDoubleLock() {}
//声明该单例模式对象的变量
private static volatile SingleLazymanDoubleLock singleLazymanDoubleLock;
//对外提供公共的访问方式
public static SingleLazymanDoubleLock getInstance() {
//第一次判断,如果singleLazymanDoubleLock的值不为null,那么就不要抢占锁,直接返回对象
//如果为null,那么给它加一把锁
if (singleLazymanDoubleLock == null) {
synchronized (SingleLazymanDoubleLock.class) {
//第二次判断
if (singleLazymanDoubleLock == null) {
singleLazymanDoubleLock = new SingleLazymanDoubleLock();
}
}
}
return singleLazymanDoubleLock;
}
/*
* 该类的一些方法
* */
public void printR() {
System.out.println("R");
}
}

public class Client {
public static void main(String[] args) {
SingleLazymanSync instance = SingleLazymanSync.getInstance();
}
}

懒汉式-----静态内部类

// 静态内部类单例模式中,由内部类创建,由于 JVM在加载外部类的过程中,是不会加载静态内部类的, 只有静态内部类的属性/方法,被调用时才会被加载,
// 并初始化其静态属性. 静态属性由于被static修饰,保证只被实例化一次,并且严格保证实例化顺序.
//第一次加载SingletonLazymanInnerClass的时候不会初始化INSTANCE,只有第一次调用getInstance,虚拟机加载SingletonHolder并初始化
//INSTANCE,这样不仅能确保线程安全,也能保证SingletonLazymanInnerClass的唯一性
public class SingletonLazymanInnerClass {
//私有构造方法
private SingletonLazymanInnerClass() {}
//定义一个静态内部类
private static class SingletonHolder {
//在内部类中声明并初始化外部类的对象 为了防止外界对他进行修改---->加上final关键字
private static final SingletonLazymanInnerClass INSTANCE = new SingletonLazymanInnerClass();
}
//提供一个公共的访问方式
public static SingletonLazymanInnerClass getInstance() {
return SingletonHolder.INSTANCE;
}
/*
* 该类的一些方法,
* */
public void printL() {
System.out.println("L");
}
}

5.恶汉式-----枚举

枚举类实现单例模式是极力推荐的单例模式,因为枚举类型是线程安全的,并且只会装载一次,设计者充分利用了枚举的这个特性来实现单例模式

// 不考虑内存浪费空间的时候首选枚举类型
public enum SingletonEvilEnum {
INSTANCE;
}

public class Client {
public static void main(String[] args) {
SingletonEvilEnum instance = SingletonEvilEnum.INSTANCE;
SingletonEvilEnum instance2 = SingletonEvilEnum.INSTANCE;
System.out.println(instance == instance2);
//结果为true,可以看出枚举类的单例模式两次获取到的对象是同一个对象
}
}


推荐阅读
  • Hadoop MapReduce 实战案例:手机流量使用统计分析
    本文通过一个具体的Hadoop MapReduce案例,详细介绍了如何利用MapReduce框架来统计和分析手机用户的流量使用情况,包括上行和下行流量的计算以及总流量的汇总。 ... [详细]
  • 在Java开发中,保护代码安全是一个重要的课题。由于Java字节码容易被反编译,因此使用代码混淆工具如ProGuard变得尤为重要。本文将详细介绍如何使用ProGuard进行代码混淆,以及其基本原理和常见问题。 ... [详细]
  • 深入解析Java中的空指针异常及其预防策略
    空指针异常(NullPointerException,简称NPE)是Java编程中最常见的异常之一。尽管其成因显而易见,但开发人员往往容易忽视或未能及时采取措施。本文将详细介绍如何有效避免空指针异常,帮助开发者提升代码质量。 ... [详细]
  • 2020年9月15日,Oracle正式发布了最新的JDK 15版本。本次更新带来了许多新特性,包括隐藏类、EdDSA签名算法、模式匹配、记录类、封闭类和文本块等。 ... [详细]
  • 本文介绍了一个将 Java 实体对象转换为 Map 的工具类,通过反射机制获取实体类的字段并将其值映射到 Map 中,适用于需要将对象数据结构化处理的场景。 ... [详细]
  • SpringBoot底层注解用法及原理
    2.1、组件添加1、Configuration基本使用Full模式与Lite模式示例最佳实战配置类组件之间无依赖关系用Lite模式加速容器启动过程,减少判断配置类组 ... [详细]
  • 如何使用Maven将依赖插件一并打包进JAR文件
    本文详细介绍了在使用Maven构建项目时,如何将所需的依赖插件一同打包进最终的JAR文件中,以避免手动部署依赖库的麻烦。 ... [详细]
  • Java多线程售票案例分析
    本文通过一个售票系统的实例,深入探讨了Java中的多线程技术及其在资源共享和并发控制中的应用。售票过程涉及查询、收款、找零和出票等多个步骤,其中对总票数的管理尤为关键。 ... [详细]
  • 本文基于Java官方文档进行了适当修改,旨在介绍如何实现一个能够同时处理多个客户端请求的服务端程序。在前文中,我们探讨了单客户端访问的服务端实现,而本篇将深入讲解多客户端环境下的服务端设计与实现。 ... [详细]
  • Android 中的布局方式之线性布局
    nsitionalENhttp:www.w3.orgTRxhtml1DTDxhtml1-transitional.dtd ... [详细]
  • Maven + Spring + MyBatis + MySQL 环境搭建与实例解析
    本文详细介绍如何使用MySQL数据库进行环境搭建,包括创建数据库表并插入示例数据。随后,逐步指导如何配置Maven项目,整合Spring框架与MyBatis,实现高效的数据访问。 ... [详细]
  • 使用TabActivity实现Android顶部选项卡功能
    本文介绍如何通过继承TabActivity来创建Android应用中的顶部选项卡。通过简单的步骤,您可以轻松地添加多个选项卡,并实现基本的界面切换功能。 ... [详细]
  • 本文详细介绍了Android系统的四层架构,包括应用程序层、应用框架层、库与Android运行时层以及Linux内核层,并提供了如何关闭Android系统的步骤。 ... [详细]
  • JVM钩子函数的应用场景详解
    本文详细介绍了JVM钩子函数的多种应用场景,包括正常关闭、异常关闭和强制关闭。通过具体示例和代码演示,帮助读者更好地理解和应用这一机制。适合对Java编程和JVM有一定基础的开发者阅读。 ... [详细]
  • 本文详细探讨了在Java编程语言中,构造函数、静态代码块和构造代码块的执行顺序。首先明确了静态代码块、构造代码块以及构造函数方法体的执行优先级,随后深入分析了构造函数体执行前的具体步骤,包括父类构造器的调用、非静态变量的初始化等。 ... [详细]
author-avatar
小英
这个家伙很懒,什么也没留下!
PHP1.CN | 中国最专业的PHP中文社区 | DevBox开发工具箱 | json解析格式化 |PHP资讯 | PHP教程 | 数据库技术 | 服务器技术 | 前端开发技术 | PHP框架 | 开发工具 | 在线工具
Copyright © 1998 - 2020 PHP1.CN. All Rights Reserved | 京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有