单例模式(Singleton Pattern):简单&粗暴解析

1.前言


2.目录

单例目录.png


3.含义

创建一个唯一的实例。


4.解决

1.全局公用资源的共享
2.一个全局使用的类频繁地创建与销毁


5.原理

5.1 例子(打印机)
  • 有一台打印机,有3个人需要打印,第一个人在打印时,需要先把打印机接上电源再打印,然后其他人打印时,就可以直接打印不需再次接收电源。
    示例图
5.2 结合例子
  • 类比图
    示意图
  • 实例
// 单例
public class Singleton {
    public static volatile Singleton Singleton3;
    public static Singleton getInstance3(){
        if(Singleton3==null){
            synchronized (Singleton.class){
                if(Singleton3==null){
                    //开机
                    Singleton3 = new Singleton();
                }
            }
        }
        return Singleton3;
    }
    public void print(String text){ 
        // 打印
    }
}    
// 调用
Singleton.getInstance3().print("打印任务A");
Singleton.getInstance3().print("打印任务B");
Singleton.getInstance3().print("打印任务C");

6.优点

1.提供了对唯一实例的受控访问,同时只能处理一个访问。
2.节约系统资源。


7.缺点

1.没有抽象层,难扩展。
2.单例类的职责过重,在一定程度上违背了“单一职责原则”。


8.六种使用方式

8.1 饿汉式:线程安全,类加载时就初始化,浪费内存
public static Singleton Singleton = new Singleton();
    public static Singleton getIntance(){
        return Singleton;
    }
8.2 懒汉式:线程不安全,懒加载
public static Singleton Singleton1;
    public static Singleton getInstance1(){
        if(Singleton1==null){
            Singleton1 = new Singleton();
        }
        return Singleton1;
    }
8.3 懒汉式:线程安全,懒加载 ,效率低
public static Singleton Singleton2;
    public static synchronized Singleton getInstance2(){
        if(Singleton2==null){
            Singleton2 = new Singleton();
        }
        return Singleton2;
    }
8.4 双检锁/双重校验锁:线程安全,懒加载 ,效率高
    public static volatile Singleton Singleton3;
    public static Singleton getInstance3(){
        if(Singleton3==null){
            synchronized (Singleton.class){
                if(Singleton3==null){
                    Singleton3 = new Singleton();
                }
            }
        }
        return Singleton3;
    }
8.5 静态内部类:线程安全,懒加载
    public static class SingletonInstance{
        public static final Singleton INSTANCEE = new Singleton();
    }
    public static Singleton getIntance4(){
        return SingletonInstance.INSTANCEE;
    }
8.6 枚举
    public enum SingletonEnum{
        INSTANCE;
        public void doSomething(){}
    }

9.总结

  • 到此, ‘单例模式’ 就解析完毕,,后续我会把上述 三大类型模式 下的各子模式进行解析分享,
    请继续关注linhaojian_简书
  • 如果喜欢我的分享,可以点击 关注 或者 ,你们支持是我分享的最大动力 。
  • linhaojian的Github

欢迎关注linhaojian_CSDN博客或者linhaojian_简书

不定期分享关于安卓开发的干货。

设计模式(Design pattern):简单&粗暴解析
单例模式(Singleton Pattern):简单&粗暴解析


写技术文章初心
  • 技术知识积累
  • 技术知识巩固
  • 技术知识分享
  • 技术知识交流
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
在Java中实现一个线程安全且性能优异的单例模式可以使用双重检查锁定(Double-Checked Locking)机制。具体的实现代码如下: ```java public class Singleton { private volatile static Singleton instance; private Singleton() { // 私有化构造方法,防止外部创建实例 } public static Singleton getInstance() { if (instance == null) { synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); } } } return instance; } } ``` 在上述代码中,通过将 `instance` 声明为 `volatile` 关键字,确保了多个线程对 `instance` 变量进行操作时的可见性。双重检查锁定机制的思路是,在实例创建之前先进行两次判断,这样可以减少不必要的同步开销提高性能。 需要注意的是,在 Java 5 以前的版本中,使用双重检查锁定机制可能会出现线程安全问题,因为 Java 5 以前的版本中的 volatile 关键字的语义不够强,可能会出现指令重排导致的问题。所以,建议在 Java 5 或更高版本中使用双重检查锁定机制。 此外,还可以使用静态内部类的方式实现线程安全且性能优异的单例模式。具体的实现代码如下: ```java public class Singleton { private Singleton() { // 私有化构造方法,防止外部创建实例 } private static class SingletonHolder { private static final Singleton INSTANCE = new Singleton(); } public static Singleton getInstance() { return SingletonHolder.INSTANCE; } } ``` 通过将实例的创建放在静态内部类中,可以保证在需要使用时才会创建实例,并且通过类加载机制保证了线程安全性。这种方式也是推荐的单例模式实现方式之一。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值