首页 > 其他分享 >2.1 单例模式【面试重点】

2.1 单例模式【面试重点】

时间：2024-08-26 20:25:39浏览次数：12  
标签：Singleton System 面试 单例 println 2.1 singleton1 out

单例模式

单例设计模式介绍

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。

比如 Hibernate 的 SessionFactory，它充当数据存储源的代理，并负责创建 Session 对象。SessionFactory 并不是轻量级的，一般情况下，一个项目通常只需要一个 SessionFactory 就够，这是就会使用到单例模式。

单例设计模式八种方式

单例模式有八种方式：

  1. 饿汉式(静态常量)
  2. 饿汉式（静态代码块）
  3. 懒汉式(线程不安全)
  4. 懒汉式(线程安全，同步方法)
  5. 懒汉式(线程安全，同步代码块)
  6. 双重检查
  7. 静态内部类
  8. 枚举

饿汉式（静态常量）

饿汉式（静态常量）应用实例

步骤如下：

  1. 构造器私有化 (防止 new )

  2. 类的内部创建对象

  3. 向外暴露一个静态的公共方法。getInstance

  4. 代码实现

public class SingletonTest {

	public static void main(String[] args) {
		Singleton singleton1 = Singleton.getSingleton();
		Singleton singleton2 = Singleton.getSingleton();
		System.out.println(singleton1==singleton2);
		System.out.println(singleton1.hashCode());
		System.out.println(singleton2.hashCode());
	}
}


// 饿汉式（静态变量）

class Singleton{
	
	// 1. 构造器私有化，外部不能new
	private Singleton() {
		
	}
	
	// 2. 在本类内部创建对象实例
	private final static Singleton SINGLETON = new Singleton();
	
	// 3. 对外提供一个公用的静态方法，返回实例对象
	public static Singleton getSingleton() {
		return SINGLETON ;
	}
	
}

优缺点说明：

  1. 优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
  2. 缺点：在类装载的时候就完成实例化，没有达到 Lazy Loading 的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费
  3. 这种方式基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数都是调用 getInstance 方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 就没有达到 lazy loading 的效果
  4. 结论：这种单例模式可用，可能造成内存浪费

饿汉式（静态代码块）

代码演示：

public class SingletonTest {

	public static void main(String[] args) {
		Singleton singleton1 = Singleton.getSingleton();
		Singleton singleton2 = Singleton.getSingleton();
		System.out.println(singleton1==singleton2);
		System.out.println(singleton1.hashCode());
		System.out.println(singleton2.hashCode());
	}

}




//饿汉式（静态变量）

class Singleton{
	
	// 1. 构造器私有化，外部不能new
	private Singleton() {
		
	}
	
	// 2. 在本类内部创建对象实例
	private static Singleton singleton ;
	
	// 3. 静态代码块创建单例对象
	static{
		singleton = new Singleton() ;
	}

	// 4. 对外提供一个公用的静态方法，返回实例对象
	public static Singleton getSingleton() {
		return singleton ;
	}
	
}

优缺点说明：

  1. 这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。
  2. 结论：这种单例模式可用，但是可能造成内存浪费

懒汉式(线程不安全)

代码演示

public class SingletonTest {

	public static void main(String[] args) {
		Singleton singleton1 = Singleton.getSingleton();
		Singleton singleton2 = Singleton.getSingleton();
		System.out.println(singleton1==singleton2);
		System.out.println(singleton1.hashCode());
		System.out.println(singleton2.hashCode());
	}

}


class Singleton{
	
	// 1. 构造器私有化，外部不能new
	private Singleton() {
		
	}
	
	// 2. 在本类内部创建对象实例
	private static Singleton singleton ;
	
	// 3. 对外提供一个公用的静态方法，当时用该方法时，才创建
	public static Singleton getSingleton() {
		if(singleton == null ) {
			singleton = new Singleton();
		}
		return  singleton ;
	}
	
}

优缺点说明：

  1. 起到了 Lazy Loading 的效果，但是只能在单线程下使用。
  2. 如果在多线程下，一个线程进入了 if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式
  3. 结论：在实际开发中，不要使用这种方式.

懒汉式(线程安全，同步方法)

代码演示：

public class SingletonTest {

	public static void main(String[] args) {
		Singleton singleton1 = Singleton.getSingleton();
		Singleton singleton2 = Singleton.getSingleton();
		System.out.println(singleton1==singleton2);
		System.out.println(singleton1.hashCode());
		System.out.println(singleton2.hashCode());
	}

}


class Singleton{
	
	// 1. 构造器私有化，外部不能new
	private Singleton() {
		
	}
	
	// 2. 在本类内部创建对象实例
	private static Singleton singleton ;
	
	// 3. 对外提供一个公用的静态方法，当时用该方法时，才创建
	// 加入同步处理的代码
	public static synchronized Singleton getSingleton() {
		if(singleton == null ) {
			singleton = new Singleton();
		}
		return  singleton ;
	}
	
}

优缺点说明：

  1. 解决了线程安全问题
  2. 效率太低了，每个线程在想获得类的实例时候，执行 getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。方法进行同步效率太低
  3. 结论：在实际开发中，不推荐使用这种方式

懒汉式(线程安全，同步代码块)

【不推荐使用】

public class SingletonTest {

	public static void main(String[] args) {
		Singleton singleton1 = Singleton.getSingleton();
		Singleton singleton2 = Singleton.getSingleton();
		System.out.println(singleton1==singleton2);
		System.out.println(singleton1.hashCode());
		System.out.println(singleton2.hashCode());
	}

}

class Singleton{
	
	// 1. 构造器私有化，外部不能new
	private Singleton() {
		
	}
	
	// 2. 在本类内部创建对象实例
	private static Singleton singleton ;
	
	// 3. 对外提供一个公用的静态方法，当时用该方法时，才创建
	// 加入同步处理的代码块
	public static Singleton getSingleton() {
		if(singleton == null ) {
			synchronized(Singleton.class) {
				singleton = new Singleton();
			}
		}
		return  singleton ;
	}
	
}

双重检查

代码演示

public class SingletonTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Singleton singleton1 = Singleton.getSingleton();
		Singleton singleton2 = Singleton.getSingleton();
		System.out.println(singleton1==singleton2);
		System.out.println(singleton1.hashCode());
		System.out.println(singleton2.hashCode());
	}

}


class Singleton{
	
	// 1. 构造器私有化，外部不能new
	private Singleton() {
		
	}
	
	// 2. 在本类内部创建对象实例
	private volatile static Singleton singleton ;
	
	// 3. 提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
	// 同时保证了效率, 推荐使用
	public static Singleton getSingleton() {
		if(singleton == null ) {
			synchronized(Singleton.class) {
				if(singleton == null ) {
					singleton = new Singleton();
				}
			}
		}
		return  singleton ;
	}
	
}

优缺点说明：

  1. Double-Check 概念是多线程开发中常使用到的，如代码中所示，我们进行了两次 if (singleton == null)检查，这样就可以保证线程安全了。
  2. 这样，实例化代码只用执行一次，后面再次访问时，判断 if (singleton == null)，直接 return 实例化对象，也避免的反复进行方法同步.
  3. 线程安全；延迟加载；效率较高
  4. 结论：在实际开发中，推荐使用这种单例设计模式

静态内部类

代码演示：

public class 静态内部类 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Singleton singleton1 = Singleton.getSingleton();
		Singleton singleton2 = Singleton.getSingleton();
		System.out.println(singleton1==singleton2);
		System.out.println(singleton1.hashCode());
		System.out.println(singleton2.hashCode());
	}

}

// 静态内部类完成， 推荐使用
class Singleton{
	
	// 1. 构造器私有化，外部不能new
	private Singleton() {
		
	}
	
	// 静态内部类，内部存在静态属性 SINGLETON
	private static class SingletonInstance{
		private static final Singleton SINGLETON = new Singleton();
	}
	
	public static Singleton getSingleton() {
		return SingletonInstance.SINGLETON;
	}
	
}

优缺点说明：

  1. 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
  2. 静态内部类方式在 Singleton 类被装载时并不会立即实例化，而是在需要实例化时，调用 getInstance 方法，才会装载 SingletonInstance 类，从而完成 Singleton 的实例化。
  3. 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
  4. 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
  5. 结论：推荐使用

枚举

代码演示

public class 枚举 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Singleton singleton1 = Singleton.INSTANCE;
		Singleton singleton2 = Singleton.INSTANCE;
		System.out.println(singleton1==singleton2);
		System.out.println(singleton1.hashCode());
		System.out.println(singleton2.hashCode());
		
		singleton1.sayOK();
	}

}

enum Singleton{
	INSTANCE;
	public void sayOK() {
		System.out.println("OK~");
	}
}

优缺点说明

  1. 这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
  2. 这种方式是 Effective Java 作者 Josh Bloch 提倡的方式
  3. 结论：推荐使用

单例模式在 JDK 应用的源码分析

单例模式在 JDK 应用的源码分析

  1. 我们 JDK 中，java.lang.Runtime 就是经典的单例模式(饿汉式)
  2. 代码分析+Debug 源码+代码说明

在这里插入图片描述

单例模式注意事项和细节说明

  1. 单例模式保证了 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能
  2. 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new
    线程同步问题，而且还能防止反序列化重新创建新的对象。
  3. 这种方式是 Effective Java 作者 Josh Bloch 提倡的方式
  4. 结论：推荐使用

单例模式在 JDK 应用的源码分析

单例模式在 JDK 应用的源码分析

  1. 我们 JDK 中，java.lang.Runtime 就是经典的单例模式(饿汉式)
  2. 代码分析+Debug 源码+代码说明

[外链图片转存中…(img-totY8KEa-1724669119848)]

单例模式注意事项和细节说明

  1. 单例模式保证了 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能
  2. 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new
  3. 单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session 工厂等)

标签：Singleton,System,面试,单例,println,2.1,singleton1,out
From： https://blog.csdn.net/u013559614/article/details/141570981

相关文章

  • 大厂面试官：Redis分布式锁掌握的还可以啊，那你了解Redis集群下的分布式锁么？ 我：不好意思，
    大厂常问面试题，Redis集群下的分布式锁，你了解多少？希望大家能关注点赞，创作不易且没收益，您的小小举动却能给予我大大的鼓励，会激励我继续创作出高质量文章......
  • springboot面试题——简化提纯版-备战春招，秋招
    0、说一下springboot的优缺点1）优点快速构建项目。对主流开发框架的无配置集成。项目可独立运行，无须外部依赖Servlet容器。提供运行时的应用监控。极大地提高了开发、部署效率。与云计算的天然集成。2）缺点版本迭代速度很快，一些模块改动很大。由于不用自己做配置，报错时......
  • react面试题八
    一、如何优化React应用的性能？优化React应用的性能是一个多方面的过程，涵盖了从代码优化到应用架构调整等多个方面。以下是一些关键策略和技术，可以帮助你提升React应用的性能：1.代码拆分和懒加载代码拆分：将代码分割成更小的块，然后只加载当前路由或页面需要的代码块。这可......
  • react面试题九
    一、ReactRouter是如何实现单页应用的路由管理的？ReactRouter实现单页应用（SPA）的路由管理主要通过以下方式：一、路由模式ReactRouter提供了多种路由模式来适应不同的开发需求，其中主要的两种模式是HashRouter和BrowserRouter。HashRouter：使用URL的哈希部分（即#......
  • 面试 | 30个热门PyTorch面试题助你轻松通过机器学习/深度学习面试
    前言PyTorch作为首选的深度学习框架的受欢迎程度正在持续攀升，在如今的AI顶会中，PyTorch的占比已高达80%以上！本文精心整理了关键的30个PyTorch相关面试问题，帮助你高效准备机器学习/深度学习相关岗位。基础篇问题1：什么是PyTorchPyTorch是一个开源机器学习库，用于......
  • 2024年秋季招聘：大型语言模型(LLM)相关面试题汇总
    0一些基础术语大模型：一般指1亿以上参数的模型，但是这个标准一直在升级，目前万亿参数以上的模型也有了。大语言模型（LargeLanguageModel，LLM）是针对语言的大模型。175B、60B、540B等：这些一般指参数的个数，B是Billion/十亿的意思，175B是1750亿参数，这是ChatGPT大约的参数规模。强......
  • 面试：大文件拆分排除输出
    题目:    存在这样一个场景：在内存紧够存储1GB数据的情况下，如何把一个10G文件进行排序后输出，10G的文件每行数据为Long型的正整数，请代码实现；题目分析    题目核心在于以下两点：1、内存仅能够存储1GB，即不能把所有数据在内存中排序后再输出；2、源文件是无需的，需......
  • 别着急面试㊙先背完答案✅offer接到手软
    别着急面试㊙先背完答案✅offer接到手软21/100保存草稿发布文章2401_85378759未选择任何文件new面试大模型岗的小伙伴们最近面试题背的怎么样啦-大模型（LLM）面试题是面试中比较常问到的，今天给大家整理了120个常见的大模型面试题✅1、目前主流的开源模型体系有哪些？（高......
  • C++学习随笔——简单的单例设计模式实例
    点击查看代码#include<iostream>classSingleton{private://私有化构造函数，防止外部实例化Singleton(){std::cout<<"SingletonInstanceCreated!"<<std::endl;}//删除拷贝构造函数和赋值运算符，防止拷贝实例Singleton(constSin......
  • 计算机网络面试真题总结（四）
    文章收录在网站：http://hardyfish.top/文章收录在网站：http://hardyfish.top/文章收录在网站：http://hardyfish.top/文章收录在网站：http://hardyfish.top/什么是滑动窗口TCP滑动窗口是TCP协议中实现流量控制和可靠传输的关键机制。滑动窗口不仅可以防止发送端数据传输......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99