什么是单例模式？单例模式详解

于 2020-06-03 01:24:08 发布
阅读量1.9k 收藏 7
点赞数 2
文章标签： java 设计模式 多线程 面试 android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43373417/article/details/106515625
版权
本文详细介绍了单例模式的概念、作用、工作原理，以及在Java中单例模式的六种实现方式，包括饿汉式、枚举类型、懒汉式、同步锁、双重校验锁和静态内部类。每种方式都有其适用场景和优缺点，其中静态内部类的实现方式兼顾线程安全和按需加载。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

个人印象笔记地址：https://app.yinxiang.com/fx/eaa22560-57a4-4554-8de8-b5f254090d37

单例模式介绍

1.1 模式说明

实现1个类只有1个实例化对象 & 提供一个全局访问点

1.2 作用（解决的问题）

保证1个类只有1个对象，降低对象之间的耦合度

1.3 工作原理

在Java中，我们通过使用对象（类实例化后）来操作这些类，类实例化是通过它的构造方法进行的，要是想实现一个类只有一个实例化对象，就要对类的构造方法做改变。

单例模式的一般实现：（含使用步骤）

public class Singleton {
//1. 创建私有变量 ourInstance（用以记录 Singleton 的唯一实例）
//2. 内部进行实例化
    private static Singleton ourInstance  = new  Singleton();


//3. 把类的构造方法私有化，不让外部调用构造方法实例化
    private Singleton() {
    }
//4. 定义公有方法提供该类的全局唯一访问点
//5. 外部通过调用getInstance()方法来返回唯一的实例
    public static  Singleton newInstance() {
        return ourInstance;
    }}

单例模式实例讲解

package scut.designmodel.SingletonPattern;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
     class StoreHouse {//单例仓库类
   
    private int quantity = 100; //仓库商品数量
  
    private static StoreHouse ourInstance  = new StoreHouse();  //自己在内部实例化
   
    public static StoreHouse getInstance() {   //让外部通过调用getInstance()方法来返回唯一的实例。
        return ourInstance;
    }
    
    private StoreHouse() {//封闭构造函数
    }
    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }
    public int getQuantity() {
        return quantity;
    }}


   class Carrier{//搬货工人类
    public StoreHouse mStoreHouse;
    public Carrier(StoreHouse storeHouse){
        mStoreHouse = storeHouse;
    }


    //搬货进仓库
    public void MoveIn(int i){
        mStoreHouse.setQuantity(mStoreHouse.getQuantity()+i);
    }


    //搬货出仓库
    public void MoveOut(int i){
        mStoreHouse.setQuantity(mStoreHouse.getQuantity()-i);
    }}
public class SinglePattern {//工人搬运测试
    public static void main(String[] args){


        StoreHouse mStoreHouse1 = StoreHouse.getInstance();
        StoreHouse mStoreHouse2 = StoreHouse.getInstance();


        Carrier Carrier1 = new Carrier(mStoreHouse1);
        Carrier Carrier2 = new Carrier(mStoreHouse2);


        System.out.println("两个是不是同一个？");
        if(mStoreHouse1.equals(mStoreHouse2)){
            System.out.println("是同一个");
        }else {
            System.out.println("不是同一个");
        }
        //搬运工搬完货物之后出来汇报仓库商品数量


        Carrier1.MoveIn(30);
        System.out.println("仓库商品余量："+Carrier1.mStoreHouse.getQuantity());
        Carrier2.MoveOut(50);
        System.out.println("仓库商品余量："+Carrier2.mStoreHouse.getQuantity());
      }}

测试结果： 从结果分析，使用了单例模式后，仓库类就只有一个仓库实例了，不用重复创建工厂。

两个是不是同一个？
是同一个
仓库商品余量：130
仓库商品余量：80

单例模式的特点：

优点：

  • 提供了对唯一实例的受控访问；

  • 由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能；

  • 可以根据实际情况需要，在单例模式的基础上扩展做出双例模式，多例模式。

    4.2 缺点

    1.单例类的职责过重，里面的代码可能会过于复杂，在一定程度上违背了“单一职责原则”。
    2.如果实例化的对象长时间不被利用，会被系统认为是垃圾而被回收，这将导致对象状态的丢失。

    单例模式的实现方式

  • 单例模式的实现方式有多种，根据需求场景，可分为2大类、6种实现方式。具体如下：
 

a. 初始化单例类时 即 创建单例

1. 饿汉式

这是 最简单的单例实现方式
  • 原理
    依赖  JVM类加载机制，保证单例只会被创建1次，即  线程安全
1. JVM在类的初始化阶段(即 在Class被加载后、被线程使用前)，会执行类的初始化
2. 在执行类的初始化期间，JVM会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化
 
  • 具体实现，举例 
    class Singleton {

    // 1. 加载该类时，单例就会自动被创建
    private static  Singleton ourInstance  = new  Singleton();
    
    // 2. 构造函数 设置为 私有权限
    // 原因：禁止他人创建实例
    private Singleton() {
    }
    
    // 3. 通过调用静态方法获得创建的单例
    public static  Singleton newInstance() {
        return ourInstance;
    }}

     

    应用场景： 除了初始化单例类时 即 创建单例外，继续延伸出来的是：单例对象 要求初始化速度快 & 占用内存小
     

     

     

    2.枚举类型

     

    原理
    根据枚举类型的下述特点，满足单例模式所需的  创建单例、线程安全、实现简洁的需求
     
     
    实现方式： 
    public enum Singleton{

    //定义1个枚举的元素，即为单例类的1个实例
    INSTANCE;

    // 隐藏了1个空的、私有的 构造方法
    // private Singleton () {}
}

// 获取单例的方式：Singleton singleton = Singleton.INSTANCE;

     

    注：这是  最简洁、易用 的单例实现方式：

     

    单元素的枚举类型已经成为实现  Singleton的最佳方法
     

    b. 按需、延迟创建单例

    1. 懒汉式（基础实现）

    原理
    与 饿汉式 最大的区别是： 单例创建的时机
     
    饿汉式：单例创建时机不可控，即类加载时  自动创建 单例
    懒汉式：单例创建时机可控，即有需要时，才  手动创建 单例
     
    具体实现： 
    class Singleton {
    // 1. 类加载时，先不自动创建单例
   //  即，将单例的引用先赋值为 Null
    private static  Singleton ourInstance  = null；


    // 2. 构造函数 设置为 私有权限
    // 原因：禁止他人创建实例
    private Singleton() {
    }
    
    // 3. 需要时才手动调用 newInstance（） 创建 单例   
    public static  Singleton newInstance() {
    // 先判断单例是否为空，以避免重复创建
    if( ourInstance == null){
        ourInstance = new Singleton();
        }
        return ourInstance;
    }}
    缺点：
    基础实现的懒汉式是线程不安全的，具体原因如下
     

    2. 同步锁（懒汉式的改进）

    原理
    使用同步锁  synchronized锁住 创建单例的方法 ，防止多个线程同时调用，从而避免造成单例被多次创建。
    即，getInstance（）方法块只能运行在1个线程中
    若该段代码已在1个线程中运行，另外1个线程试图运行该块代码，则 会被阻塞而一直等待
    而在这个线程安全的方法里我们实现了单例的创建，保证了多线程模式下 单例对象的唯一性
     
    具体的实现： 
    写法1class Singleton {
// 1. 类加载时，先不自动创建单例
// 即，将单例的引用先赋值为 Null
private static Singleton ourInstance = null；
// 2. 构造函数 设置为 私有权限
// 原因：禁止他人创建实例
private Singleton() {
}
// 3. 加入同步锁public static synchronized Singleton getInstance(){
// 先判断单例是否为空，以避免重复创建
if ( ourInstance == null )
ourInstance = new Singleton();
return ourInstance;
}}


// 写法2// 该写法的作用与上述写法作用相同，只是写法有所区别
class Singleton{ 

private static Singleton instance = null;

private Singleton(){
}

public static Singleton getInstance(){
// 加入同步锁
synchronized(Singleton.class) {//锁类对象？、、
if (instance == null)
instance = new Singleton();
}
return instance;
}}
    缺点：
    每次访问都要进行线程同步（即 调用 synchronized锁)，造成过多的同步开销（加锁 = 耗时、耗能）

     

    实际上只需在第1次调用该方法时才需要同步，一旦单例创建成功后，就没必要进行同步

    3. 双重校验锁（懒汉式的改进）

    原理：在同步锁的基础上，添加1层  if 判断：若单例已创建，则不需再执行加锁操作就可获取实例，从而提高性能。（上厕所，反锁了门后，再推一下，确保关闭）
    具体实现： 
    class Singleton {
private static Singleton ourInstance = null；

private Singleton() { // 构造方法私有化，禁止他人创建对象
}

public static Singleton newInstance() {
// 加入双重校验锁
// 校验锁1：第1个if
if( ourInstance == null){ // ①

synchronized (Singleton.class){ // ②

// 校验锁2：第2个 if
if( ourInstance == null){
ourInstance = new Singleton();
}
}
}
return ourInstance;
}}

// 说明// 校验锁1：第1个if// 作用：若单例已创建，则直接返回已创建的单例，无需再执行加锁操作// 即直接跳到执行 return ourInstance

// 校验锁2：第2个 if // 作用：防止多次创建单例问题// 原理
// 1. 线程A调用newInstance()，当运行到②位置时，此时线程B也调用了newInstance()
// 2. 因线程A并没有执行instance = new Singleton();，此时instance仍为空，因此线程B能突破第1层 if 判断，运行到①位置等待synchronized中的A线程执行完毕
// 3. 当线程A释放同步锁时，单例已创建，即instance已非空
// 4. 此时线程B 从①开始执行到位置②。此时第2层 if 判断 = 为空（单例已创建），因此也不会创建多余的实例
    缺点： 实现复杂 ，多种判断，易出错
     

    4. 静态内部类

    原理
    根据 静态内部类 的特性，同时解决了按需加载、线程安全的问题，同时实现简洁
    1. 在静态内部类里创建单例，在装载该内部类时才会去创建单例
    2. 线程安全：类是由 JVM加载，而JVM只会加载1遍，保证只有1个单例
    具体实现： 
    lass Singleton {

// 1. 创建静态内部类
private static class Singleton2 {
// 在静态内部类里创建单例
private static Singleton ourInstance = new Singleton()；
}

// 私有构造函数
private Singleton() {
}

// 延迟加载、按需创建
public static Singleton newInstance() {
return Singleton2.ourInstance;
}

}

// 调用过程说明：
// 1. 外部调用类的newInstance()
// 2. 自动调用Singleton2.ourInstance
// 2.1 此时单例类Singleton2得到初始化
// 2.2 而该类在装载 & 被初始化时，会初始化它的静态域，从而创建单例；
// 2.3 由于是静态域，因此只会JVM只会加载1遍，Java虚拟机保证了线程安全性
// 3. 最终只创建1个单例

    6. 总结：

     

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值