专栏首页古时的风筝从实例出发,了解单例模式和静态块

从实例出发,了解单例模式和静态块

就算你没有用到过其他的设计模式,但是单例模式你肯定接触过,比如,Spring 中 bean 默认就是单例模式的,所有用到这个 bean 的实例其实都是同一个。

单例模式的使用场景

什么是单例模式呢,单例模式(Singleton)又叫单态模式,它出现目的是为了保证一个类在系统中只有一个实例,并提供一个访问它的全局访问点。从这点可以看出,单例模式的出现是为了可以保证系统中一个类只有一个实例而且该实例又易于外界访问,从而方便对实例个数的控制并节约系统资源而出现的解决方案。

使用单例模式当然是有原因,有好处的了。在下面几个场景中适合使用单例模式:

1、有频繁实例化然后销毁的情况,也就是频繁的 new 对象,可以考虑单例模式;

2、创建对象时耗时过多或者耗资源过多,但又经常用到的对象;

3、频繁访问 IO 资源的对象,例如数据库连接池或访问本地文件;

下面举几个例子来说明一下:

1、网站在线人数统计;

其实就是全局计数器,也就是说所有用户在相同的时刻获取到的在线人数数量都是一致的。要实现这个需求,计数器就要全局唯一,也就正好可以用单例模式来实现。当然这里不包括分布式场景,因为计数是存在内存中的,并且还要保证线程安全。下面代码是一个简单的计数器实现。

public class Counter {
   
    private static class CounterHolder{
        private static final Counter counter = new Counter();
    }

    private Counter(){
        System.out.println("init...");
    }

    public static final Counter getInstance(){
        return CounterHolder.counter;
    }

    private AtomicLong online = new AtomicLong();

    public long getOnline(){
        return online.get();
    }

    public long add(){
        return online.incrementAndGet();
    }
}    

2、配置文件访问类;

项目中经常需要一些环境相关的配置文件,比如短信通知相关的、邮件相关的。比如 properties 文件,这里就以读取一个properties 文件配置为例,如果你使用的 Spring ,可以用 @PropertySource 注解实现,默认就是单例模式。如果不用单例的话,每次都要 new 对象,每次都要重新读一遍配置文件,很影响性能,如果用单例模式,则只需要读取一遍就好了。以下是文件访问单例类简单实现:

public class SingleProperty {

    private static Properties prop;

    private static class SinglePropertyHolder{
        private static final SingleProperty singleProperty = new SingleProperty();
    }

    /**
    * config.properties 内容是 test.name=kite 
    */
    private SingleProperty(){
        System.out.println("构造函数执行");
        prop = new Properties();
        InputStream stream = SingleProperty.class.getClassLoader()
                .getResourceAsStream("config.properties");
        try {
            prop.load(new InputStreamReader(stream, "utf-8"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static SingleProperty getInstance(){
        return SinglePropertyHolder.singleProperty;
    }
    
    
    public String getName(){
        return prop.get("test.name").toString();
    }

    public static void main(String[] args){
        SingleProperty singleProperty = SingleProperty.getInstance();
        System.out.println(singleProperty.getName());
    }
}

3、数据库连接池的实现,也包括线程池。为什么要做池化,是因为新建连接很耗时,如果每次新任务来了,都新建连接,那对性能的影响实在太大。所以一般的做法是在一个应用内维护一个连接池,这样当任务进来时,如果有空闲连接,可以直接拿来用,省去了初始化的开销。所以用单例模式,正好可以实现一个应用内只有一个线程池的存在,所有需要连接的任务,都要从这个连接池来获取连接。如果不使用单例,那么应用内就会出现多个连接池,那也就没什么意义了。如果你使用 Spring 的话,并集成了例如 druid 或者 c3p0 ,这些成熟开源的数据库连接池,一般也都是默认以单例模式实现的。

单例模式的实现方法

如果你在书上或者网站上搜索单例模式的实现,一般都会介绍5、6中方式,其中有一些随着 Java 版本的升高,以及多线程技术的使用变得不那么实用了,这里就介绍两种即高效,而且又是线程安全的方式。

1. 静态内部类方式

public class Singleton {  
    private static class SingletonHolder {  
        private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
        return SingletonHolder.INSTANCE; 
    }  
}

这种写法仍然使用 JVM 本身机制保证了线程安全问题,由于 SingletonHolder 是私有的,除了 getInstance() 方法外没有办法访问它,因此它是懒汉式的;同时读取实例的时候不会进行同步,没有性能缺陷;也不依赖 JDK 版本。上面的两个例子就是用这种方式实现的。

2. 枚举方式

public enum SingleEnum {

    INSTANCE;

    SingleEnum(){
        System.out.println("构造函数执行");
    }

    public String getName(){
        return "singleEnum";
    }

    public static void main(String[] args){
        SingleEnum singleEnum = SingleEnum.INSTANCE;
        System.out.println(singleEnum.getName());
    }
}

我们可以通过 SingleEnum.INSTANCE 来访问实例。而且创建枚举默认就是线程安全的,并且还能防止反序列化导致重新创建新的对象。

静态块

什么是静态块呢。

1、它是随着类的加载而执行,只执行一次,并优先于主函数。具体说,静态代码块是由类调用的。类调用时,先执行静态代码块,然后才执行主函数的;

2、静态代码块其实就是给类初始化的,而构造代码块是给对象初始化的;

3、静态代码块中的变量是局部变量,与普通函数中的局部变量性质没有区别;

4、一个类中可以有多个静态代码块;

他的写法是这样的:

static {
        System.out.println("static executed");
    }

来看一下下面这个完整的实例:

public class SingleStatic {

    static {
        System.out.println("static 块执行中...");
    }

    {
        System.out.println("构造代码块 执行中...");
    }

    public SingleStatic(){
        System.out.println("构造函数 执行中");
    }

    public static void main(String[] args){
        System.out.println("main 函数执行中");
        SingleStatic singleStatic = new SingleStatic();
    }

}

他的执行结果是这样的:

static 块执行中...
main 函数执行中
构造代码块 执行中...
构造函数 执行中

从中可以看出他们的执行顺序分别为:

1、静态代码块

2、main 函数

3、构造代码块

4、构造函数

利用静态代码块只在类加载的时候执行,并且只执行一次这个特性,也可以用来实现单例模式,但是不是懒加载,也就是说每次类加载就会主动触发实例化。

除此之外,不考虑单例的情况,利用静态代码块的这个特性,可以实现其他的一些功能,例如上面提到的配置文件加载的功能,可以在类加载的时候就读取配置文件的内容,相当于一个预加载的功能,在使用的时候可以直接拿来就用。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 动手实现 LRU 算法,以及 Caffeine 和 Redis 中的缓存淘汰策略

    那天我在 LeetCode 上刷到一道 LRU 缓存机制的问题,第 146 题,难度为中等,题目如下。

    古时的风筝
  • 『JVM』我不想知道我是怎么来滴,我就想知道我是怎么没滴

    所谓的 JVM 崩溃,一般情况下就是指内存溢出,也就是 OutOfMemoryError 和 StackOverflowError。另外还有一种情况就是堆外内存...

    古时的风筝
  • Java 进程占用内存过多,幕后元凶原来是线程太多

    我们当前这个系统和很多的第三方系统做了集成,出问题的就是其中一个三方系统。其实很简单,他们的系统会产生一些个人待办任务,然后待办任务的个数需要推送到我们的 AP...

    古时的风筝
  • 设计模式(1)-单例模式

    单例模式,是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例。即一个类只有一个对象实例。

    秦子帅
  • 单例设计模式(java与node实现)

    单例模式,是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中,应用该模式的类一个类只有一个实例。即一个类只有一个...

    许喜朝
  • 单例模式的八种写法

    单例模式作为日常开发中最常用的设计模式之一,是最基础的设计模式,也是最需要熟练掌握的设计模式。单例模式的定义是:保证一个类仅有一个实例,并提供一个访问它的全局访...

    王金龙
  • 设计模式二十四章经之单例设计模式

    我就是马云飞
  • 单例模式 Java 简介 学习笔记 及多种实现方式

    在我们的系统中,有一些对象其实我们只需要一个,比如说:线程池、缓存、对话框、注册表、日志对象、充当打印机、显卡等设备驱动程序的对象。事实上,这一类对象只能有一个...

    大鹅
  • 写了这么久代码,你懂单例模式吗?

    这种方式在类加载时就完成了初始化,所以类加载较慢,但获取对象的速度快。这种方式基于类加载机制避免了多线程的同步问题,但是也不能确定有其他的方式(或者其他的静态方...

    咻咻ing
  • 进击的爬虫:用Python搭建匿名代理池

    專 欄 ❈ 苍冥,Python中文社区专栏作者,澳洲华裔,目前在墨尔本某国际咨询公司任职Splunk Developer,擅长网络安全及攻防,热爱Python...

    Python中文社区

扫码关注云+社区

领取腾讯云代金券