第四章 单例模式

已于 2022-06-23 08:51:59 修改
阅读量219 收藏
点赞数
分类专栏： Java设计模式浅析 文章标签： 单例模式 java 开发语言
于 2022-06-23 08:50:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/runoob/article/details/125388799
版权
本文深入探讨了Java中的单例模式，包括饿汉式、懒汉式（线程不安全、同步、双重检查）、注册式（枚举与容器）以及线程局部单例实现。详细介绍了每种实现方式的示例代码和测试，总结了单例模式的优缺点及其在多线程环境中的应用。
摘要由CSDN通过智能技术生成

Java设计模式浅析

第一章 简单工厂模式
第二章 工厂方法模式
第三章 抽象工厂模式
第四章 单例模式

文章目录

···

单例模式概述

单例模式（Singleton Pattern）是指确保一个类在任何情况下都
绝对只有一个实例，并提供一个全局访问点。
单例模式是创建性模式。单例模式在开发中应用非常广泛，
例如，Spring 框架中的 ApplicationContext、数据库的连接池等。

单例模式有如下实现方式:
● 饿汉式
● 懒汉式
● 注册式

饿汉单例模式

饿汉式单例是在类加载的时候就立即初始化，并且创建单例对象。它绝对线程安全，在线程还没出现以前就是实例化了，不可能存在访问安全问题。

Spring 中 IOC 容器 ApplicationContext 本身就是典型的饿汉式单例模式。

1、示例代码

public  class HungrySingleton {
    // 1.私有构造
    private HungrySingleton (){}
    // 2.在类的内部创建自行实例
    private static final HungrySingleton instance = new HungrySingleton();
    // 3.提供获取唯一实例的方法（全局访问点）
    public static HungrySingleton getInstance(){
        return instance;
    }

    public  void leaveBuilding1(){
        System.out.println("void：Hello1 World1");
    }

    public static void leaveBuilding(){
        System.out.println("static void： Hello World");
    }
}
2、测试代码

public class SingletonTest {
  public static void main(String[] args) {
    HungrySingleton a = HungrySingleton.getInstance();
    //getInstance 获取实例 
    a.leaveBuilding1();
    
    //静态类的静态方法直接调用
    HungrySingleton.leaveBuilding();
    System.out.println(HungrySingleton.getInstance());
    System.out.println(HungrySingleton.getInstance());

    System.out.println(HungryStaticSingleton.getInstance());
    System.out.println(HungryStaticSingleton.getInstance());

  }
}

运行结果

懒汉单例模式（线程不安全）

构造器私有!!!
暴露getInstance()方法!!!
在第一次被调用的时候进行初始化

1、示例代码
public class LazySimpleSingleton {
    private LazySimpleSingleton() {
    }
    //静态实例 默认置为NULL
    private static LazySimpleSingleton lazy = null;

    public static LazySimpleSingleton getInstance() {
        if (lazy == null) {
            lazy = new LazySimpleSingleton();
        }
        return lazy;
    }
}
2、测试代码
public class LazySingletonTest {
    public static void main(String[] args) {
        //创建线程 调用run()方法
        //线程不安全的
        Thread t1 = new Thread(new ExectorThread());
        Thread t2 = new Thread(new ExectorThread()); 
        t2.start();
        System.out.println("线程不安全");
        t1.start();
  }
}

在这里插入图片描述

懒汉单例模式（synchronized）

1、示例代码

ExectorThread

public class ExectorThread implements Runnable{
    @Override
    public void run() {
        //run方法实现 runnable 接口
        LazySimpleSingleton singleton = LazySimpleSingleton.getInstance();
        System.out.println(Thread.currentThread().getName() + ":" + singleton);
    }
}

ExectorThread

public class ExectorThread implements Runnable {
  @Override
    public void run() {
        //run方法实现 runnable 接口
        LazySimpleSyncSingleton singleton = LazySimpleSyncSingleton.getInstance();
        System.out.println(Thread.currentThread().getName() + ":" + singleton);
    }
}

LazySimpleSyncSingleton

public class LazySimpleSyncSingleton {
    private LazySimpleSyncSingleton() {
    }

    private static LazySimpleSyncSingleton instance = null;

    public synchronized static LazySimpleSyncSingleton getInstance() {
        //通过给 getInstance() 方法加上 synchronized 关键字，使这个方法编程线程同步方法：
        if (instance == null) {
            instance = new LazySimpleSyncSingleton();
        }
        return instance;
    }
}
2、测试代码
public class LazySingletonTest {

    public static void main(String[] args) {
        //创建线程 调用run()方法
        //线程不安全的
        Thread t1 = new Thread(new ExectorThread());
        Thread t2 = new Thread(new ExectorThread());
       
        t2.start();
        System.out.println("线程不安全");
        t1.start();

        Thread t3 = new Thread(new ExectorThreadSycr());
        Thread t4 = new Thread(new ExectorThreadSycr());
       
       //synchronized 加锁时，在线程数量比较多的情况下，
       //如果 CPU 分配压力上升，则会导致大批线程阻塞，
       //从而导致程序性能大幅下降。
        t3.start();
        System.out.println("线程安全的,但是有性能问题");
        t4.start();

  }
}

加synchronized
加synchronized

懒汉单例模式（双重检查）

1、示例代码

ExectorThreadDc

public class ExectorThreadDc implements Runnable {
    @Override
    public void run() {
        //run方法实现 runnable 接口
        LazyDoubleCheckSingleton singleton = LazyDoubleCheckSingleton.getInstance();
        System.out.println(Thread.currentThread().getName() + ":" + singleton);
    }
}

LazyDoubleCheckSingleton

public class LazyDoubleCheckSingleton {
    private LazyDoubleCheckSingleton() {}

    private volatile static LazyDoubleCheckSingleton instance = null;

    public static LazyDoubleCheckSingleton getInstance() {
        //双重检查锁
        if (instance == null) {
            synchronized (LazyDoubleCheckSingleton.class) {
                if (instance == null) {
                    instance = new LazyDoubleCheckSingleton();// error
                }
            }
        }
        return  instance;
    }
}
2、测试代码
public class LazySingletonTest {
    public static void main(String[] args) {
        //创建线程 调用run()方法
        //线程不安全的
        Thread t1 = new Thread(new ExectorThread());
        Thread t2 = new Thread(new ExectorThread());
       
        t1.start();
        t2.start();
        System.out.println("线程不安全");


        Thread t3 = new Thread(new ExectorThreadSycr());
        Thread t4 = new Thread(new ExectorThreadSycr());
       
       //synchronized 加锁时，在线程数量比较多的情况下，
       //如果 CPU 分配压力上升，则会导致大批线程阻塞，
       //从而导致程序性能大幅下降。
       System.out.println("线程安全的,但是有性能问题");
       t3.start();
       t4.start();
      //重排序问题
      //需要在 instance 前加入关键字 volatile。使用了 volatile 关键字后，
      //重排序被禁止，所有的写（write）操作都将发生在读（read）操作之前。
       Thread t5 = new Thread(new ExectorThreadDc());
       Thread t6 = new Thread(new ExectorThreadDc());
       t5.start();
       t6.start();
       System.out.println("double check");
  }
}

在这里插入图片描述

注册式单例模式

注册式单例模式

注册式单例又称为登记式单例，就是将每一个实例都登记到某一个地方，
使用唯一的标识获取实例。
注册式单例有两种写法:

一种为枚举式单例模式，
一种为容器式单例模式。

枚举单例

1、示例代码

EnumSingleton

//这是一个枚举类型
public enum  EnumSingleton {
    INSTANCE;
    private  Object  data;
    public Object getData() {
        return data;
    }
    public void setData(Object data) {
        this.data = data;
    }
    public static EnumSingleton getInstance(){
        return INSTANCE;
    }
}
2、测试代码
import java.io.*;

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

        EnumSingleton instance1 = null;
        EnumSingleton instance2 = EnumSingleton.getInstance();
        instance2.setData(new Object());

        try {
            //序列化
            FileOutputStream fos = new FileOutputStream("EnumSingletonTest.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(instance2);
            oos.flush();
            oos.close();

            //反序列化
            FileInputStream fis = new FileInputStream("EnumSingletonTest.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            instance1 = (EnumSingleton) ois.readObject();
            ois.close();

            System.out.println(instance1.getData());
            System.out.println(instance2.getData());
            System.out.println(instance1.getData() == instance2.getData());
       
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述
为什么枚举式单例模式能够避免反射对单例模式的破坏？
枚举的详细说明—源码分析

容器单例

1、示例代码

Pojo

public class Pojo {

}

package com.Design.Singleton.RegisSing;
import java.util.*; 
import java.util.concurrent.*;
/*
*容器式单例用Map实现
*一般以类名
*实例名为键值对存放进私有Map中
*容器式单例适用于管理的实例非常多的情况
*非线程安全。
*/
public class ContainerSingleton {
    private ContainerSingleton(){}
    private static Map<String,Object> ioc = new ConcurrentHashMap<String,Object>();
    public static Object getInstance(String className){
        synchronized (ioc) {
            if (!ioc.containsKey(className)) {
                Object obj = null;
                try {
                    //装载类 包名+类名
                    obj = Class.forName(className).newInstance();
                    //put 到 Map 中
                    ioc.put(className, obj);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return obj;
            } else {
                return ioc.get(className);
            }
        }
    }
}

ContainerSingleThread

public class ContainerSingleThread implements Runnable{
   @Override
    public void run() {
        //获取实例对象
        Pojo instance= (Pojo) ContainerSingleton.getInstance("com.Design.Singleton.RegisSing.Pojo");
        System.out.println(Thread.currentThread().getName()+"--->"+instance);
    }
}
2、测试代码
public class ContainerSingleTest {
    public static void main(String[] args) {
        Thread t1 = new Thread(new ContainerSingleThread());
        Thread t2 = new Thread(new ContainerSingleThread());
        t1.start();
        t2.start();
    }
}

在这里插入图片描述

线程单例实现

  • 线程单例使用 ThreadLocal 来实现。
  • ThreadLocal 不能保证其创建的对象是全局唯一，但是能保证在单个线程中是唯一的，天生的线程安全。
1、示例代码

ThreadLocalSigleton

public class ThreadLocalSigleton {
    private static final ThreadLocal<ThreadLocalSigleton> threadLocalInstance 
        = new ThreadLocal<ThreadLocalSigleton>(){
        @Override
        //java.lang.ThreadLocal.initialValue()方法
        //返回此线程局部变量的当前线程的initial value 
        protected ThreadLocalSigleton initialValue() {
            return new ThreadLocalSigleton();
        }
    };
    //私有构造器
    private ThreadLocalSigleton(){};
 
    public static ThreadLocalSigleton getInstance(){
        return threadLocalInstance.get();
    }
}
2、测试代码
public class ThreadLocalSigletonTest {
    public static void main(String[] args) {
        ThreadLocalSigleton a =  ThreadLocalSigleton.getInstance();
        ThreadLocalSigleton a1 = ThreadLocalSigleton.getInstance();
        ThreadLocalSigleton a2 = ThreadLocalSigleton.getInstance();
        ThreadLocalSigleton a3 = ThreadLocalSigleton.getInstance();
        System.out.println(a);
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);
    }
}

在这里插入图片描述

我们发现，在主线程中无论调用多少次，获得到的实例都是同一个；在多线程环境下，每个线程获取到了不同的实例。

总结

单例模式为了达到线程安全的目的，会给方法上锁，以时间换空间。
ThreadLocal 将所有的对象放在 ThreadLocalMap 中，为每个线程都提供一个对象，这实际上是以空间换时间来实现线程间隔离的。

runoob
关注
专栏目录
第04章 面向对象（上） 13 单例设计模式
09-12
在Java中，实现单例模式主要有以下几种方式： 1. **饿汉式（静态常量）**：这是最简单的单例实现，它在类加载时就完成了初始化，所以是线程安全的。但是由于类加载时就创建了单例对象，即使没有被使用也会占用内存...
第四章：Spring AOP API 设计模式1
08-03
5. **单例模式（Singleton）**：Spring AOP中的`SingletonTargetSource`保证了每个目标对象只被创建一次，实现了单例模式，确保在整个应用程序中只有一个共享的实例存在，提高了资源利用效率。 6. **适配器模式...
第3章 软件体系结构风格_设计模式_
09-29
1. 创建型模式：如单例模式（确保类只有一个实例）、工厂模式（提供创建对象的接口）、抽象工厂模式（提供创建相关对象家族的接口）等，关注对象的创建过程。 2. 结构型模式：如适配器模式（使不兼容接口之间能协同...
安卓知识小结第一章
04-11
- 单例模式（singleInstance）：类似栈内模式，但整个任务栈只包含该Activity一个实例，防止其他Activity进入。 3. 任务栈：任务栈是按照先进后出（FIFO）原则管理Activity的队列。按回退键时，栈顶的Activity出栈...
深入浅出设计模式第一章中文.zip
05-20
创建型模式关注对象的创建过程，如工厂模式、抽象工厂模式、单例模式、建造者模式和原型模式。结构型模式处理类和对象的组合，如适配器模式、装饰器模式、代理模式、桥接模式、组合模式、外观模式和享元模式。行为型...
漫谈设计模式 [3]：单例模式
刘炫320的博客
09-07 1140
菜鸟：听起来不错，但具体怎么实现呢？老鸟：我们可以用生活中的例子来理解单例模式。想象一下，你家里有一个电灯开关，每次你要开灯或关灯你都会去同一个地方操作，这个开关就相当于单例。你不会为每个灯泡都创建一个新的开关。菜鸟：那这样说来，单例模式就是为了确保某些资源只会有一个实例存在，对吧？老鸟：没错！接下来我们用Python代码来实现一下。老鸟：今天我们通过对话了解了单例模式的概念、实现方法、优势和适用场景。你觉得有帮助吗？菜鸟我对设计模式越来越感兴趣了。接下来有什么推荐的吗？老鸟。
单例模式解析
Baron的博客
09-10 788
一种常用的软件设计模式，它确保，并提供一个全局访问点来获取这个实例。
『功能项目』单例模式框架【37】
weixin_69360830的博客
09-10 502
单例模式框架
单例模式的学习
weixin_51883798的博客
09-10 310
【代码】单例模式的学习。
Java面试题·解释题·单例模式、工厂模式、代理模式部分
howwickhappy的博客
09-10 1146
本文将介绍：单例模式、工厂模式、代理模式，本文主要介绍以上部分的面试题。
设计模式之单例模式(通俗易懂--代码辅助理解【Java版】）
qq_45929019的博客
09-10 1114
创建型模式：工厂方法、抽象方法、建造者、原型、单例。结构型模式有：适配器、桥接、组合、装饰器、外观、享元、代理。行为型模式有：责任链、命令、解释器、迭代器、中介、备忘录、观察者、状态、策略、模板方法、访问者。常用设计模式：单例模式、工厂模式、代理模式、策略模式&模板模式、门面模式、责任链模式、装饰器模式、组合模式、builder模式。单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
spring事务详细讲解-深入浅出
小电玩
09-08 527
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1512
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
自动生成不重复的订单id
ClaireCheney的博客
09-13 176
【代码】自动生成不重复的订单id。
Java集合：Stack详解
yang_brother的博客
09-10 571
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 606
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
基于SpringBoot的考研资讯平台设计与实现
最新发布
linzhongshu的专栏
09-13 549
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
MyBatis面试
Tony_yitao的博客
09-09 777
MyBatis面试
Linux服务器Java启动脚本
Jack魏
09-08 569
本文章介绍了如何在Linux服务器上执行Java并启动jar包，通常我们会使用nohup直接启动，但是还是需要手动停止然后再次启动，那如何更优雅的在服务器上启动jar包呢，让我们一起探讨一下吧。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值