Java单例模式的7种用法以及使用问题

最新推荐文章于 2024-03-31 02:04:09 发布
最新推荐文章于 2024-03-31 02:04:09 发布
阅读量328 收藏 1
点赞数
分类专栏： Java基础 文章标签： java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hu294902290/article/details/105600537
版权

Java 单例模式的几种用法

1.概念

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

2.饿汉式单例

	1.1 饿汉式单例

/**
 * 饿汉式单例
 * 
 * @author a_bo
 * @version 创建时间：2020年4月18日 下午4:09:42
 */
public class HungrySingleton {

	private static final HungrySingleton SINGLETON = new HungrySingleton();

	public static HungrySingleton getInstance() {
		return SINGLETON;
	}

	private HungrySingleton() {
	}

	public static void main(String[] args) {
		HungrySingleton s1 = HungrySingleton.getInstance();
		System.out.println("s1" + s1);
	}
}

	1.2 饿汉式静态代码块单例

/**
 * 饿汉式静态代码块单例
 * 
 * @author a_bo
 * @version 创建时间：2020年4月18日 下午4:15:18
 */
public class HungryStaticSingleton {

	private static final HungryStaticSingleton SINGLETON;
	static {
		SINGLETON = new HungryStaticSingleton();
	}

	public static HungryStaticSingleton getInstance() {
		return SINGLETON;
	}

	private HungryStaticSingleton() {
	}

	public static void main(String[] args) {
		HungryStaticSingleton s1 = HungryStaticSingleton.getInstance();
		System.out.println(s1);
	}
}

特点

1.饿汉式单例, 使用static修饰全局唯一, 在类加载的时候就会初始化, 线程安全 
2.如果有大批量的饿汉式单例, 系统初始化时会占用大量内存

3.懒汉式单例

	3.1 懒汉式单例

/**
 * 懒汉式单例
 * 
 * @author a_bo
 * @version 创建时间：2020年4月18日 下午5:10:46
 */
public class LazySingleton {

	private static LazySingleton singleton;

	private LazySingleton() {
	}

	private static LazySingleton getInstance() {
		if (singleton == null) {
			singleton = new LazySingleton();
		}
		return singleton;
	}

	public static void main(String[] args) {
		LazySingleton instance = LazySingleton.getInstance();
		System.out.println(instance);
	}
}

特点

	1.使用懒加载, 使用的时候才会去创建, 节省了初始化的内存空间
	2.在多线程的场景下会有几率创建两个不一样的单例对象, singleton == null 线程不安全

3.2 饿汉式同步锁单例

/**
 * 懒汉式单例
 * 
 * @author a_bo
 * @version 创建时间：2020年4月18日 下午5:10:46
 */
public class LazySingleton {

	private static LazySingleton singleton;

	private LazySingleton() {
	}

	private static synchronized LazySingleton getInstance() {
		if (singleton == null) {
			singleton = new LazySingleton();
		}
		return singleton;
	}

	public static void main(String[] args) {
		LazySingleton instance = LazySingleton.getInstance();
		System.out.println(instance);
	}
}

特点

	1.可以解决线程安全问题, 但是在多线程的场景下, 第一个线程进入同步方法后其余的线程会进行阻塞

4.双重检验锁单例

/**
 * 双重检验锁单例
 * 
 * @author a_bo
 * @version 创建时间：2020年4月18日 下午5:33:55
 */
public class DoubleCheckSingleton {

	private volatile static DoubleCheckSingleton singleton;

	private DoubleCheckSingleton() {
	}

	public static DoubleCheckSingleton getInstance() {
		if (singleton == null) {
			synchronized (DoubleCheckSingleton.class) {
				if (singleton == null) {
					singleton = new DoubleCheckSingleton();
				}
			}
		}
		return singleton;
	}

}

特点

	1.相对于同步锁的单例, 双重检验锁的粒度更小, 而且DoubleCheckSingleton初始化后不会再进行
	同步的操作
	2.当多线程执行调用getInstance, 假设A线程先获取到锁, B线程阻塞, 在A线程初始化后通过volatile
	关键字将singleton 对象刷新到主内存, 保证了可见性, 然后释放锁, 此时B获取到锁, 判断 singleton 
	不为空, 就可以返回有值的对象

5.反射破坏单例

/**
 * 反射破坏单例创建多个实例
 * 
 * @author a_bo
 * @version 创建时间：2020年4月18日 下午5:57:26
 */
public class ReflectSingletonTest {

	public static void main(String[] args) throws Exception {
		// 通过静态方法获取单例
		DoubleCheckSingleton s1 = DoubleCheckSingleton.getInstance();
		// 通过反射用构造方法创建对象
		Class<?> clazz = DoubleCheckSingleton.class;
		Constructor<?> constructor = clazz.getDeclaredConstructor();
		constructor.setAccessible(true);
		DoubleCheckSingleton s2 = (DoubleCheckSingleton) constructor.newInstance();
		DoubleCheckSingleton s3 = (DoubleCheckSingleton) constructor.newInstance();
		System.out.println(s2 == s3);//false
		System.out.println(s1 == s2);//false
		System.out.println(s1 == s3);//false
	}
}

特点

	1.通过反射用构造方法创建出多个实例对象, 并且每个对象地址值不一致

解决办法

	可以对无参构造进行判断当前类的实例是否被创建

private volatile static DoubleCheckSingleton singleton;

	private DoubleCheckSingleton() {
		if (singleton != null) {
			throw new RuntimeException("不允许创建对象");
		}
	}

6.静态内部类单例

/**
 * 静态内部类单例
 * 
 * @author a_bo
 * @version 创建时间：2020年4月18日 下午6:07:14
 */
public class LazyInnerSingleton {

	private LazyInnerSingleton() {
		if (LazySingletoncreator.SINGLETON != null) {
			throw new RuntimeException("不允许创建对象");
		}
	}

	public static final LazyInnerSingleton getInstance() {
		return LazySingletoncreator.SINGLETON;
	}

	private static class LazySingletoncreator {
		private static final LazyInnerSingleton SINGLETON = new LazyInnerSingleton();
	}
}

特点

	1.内部类默认是不会被加载, 当使用时候才会被加载, SINGLETON 常量全局唯一只会创建一份, 保证了
	单例

7.序列化破坏单例

	1.将LazyInnerSingleton  实现序列化接口
	2.通过序列化再反序列化创建对象

/**
 * 序列化破坏单例测试
 * 
 * @author a_bo
 * @version 创建时间：2020年4月18日 下午6:25:59
 */
public class SerializableSingletonTest {

	public static void main(String[] args) throws Exception {
		LazyInnerSingleton s1 = LazyInnerSingleton.getInstance();

		// 创建输出流写入
		FileOutputStream os = new FileOutputStream("LazyInnerSingleton.java");
		ObjectOutputStream oos = new ObjectOutputStream(os);
		oos.writeObject(s1);
		oos.close();
		// 创建输入流读
		FileInputStream is = new FileInputStream("LazyInnerSingleton.java");
		ObjectInputStream ois = new ObjectInputStream(is);
		LazyInnerSingleton s2 = (LazyInnerSingleton) ois.readObject();
		oos.close();
		System.out.println(s1 == s2);//false
	}
}

特点

	1.通过序列化再发序列化会创建一个新对象

** 解决办法**

	1.在序列化的类中增加readResolve方法, ObjectInputStream 在底层会反射调用readResolve 
	感兴趣的可以看源码更一下

/**
 * 静态内部类单例
 * 
 * @author a_bo
 * @version 创建时间：2020年4月18日 下午6:07:14
 */
public class LazyInnerSingleton implements Serializable {
	private static final long serialVersionUID = 1530724903774028685L;
	/** 反序列化的时候返回的对象 */
	public Object readResolve() {
		return LazySingletoncreator.SINGLETON;
	}

	private LazyInnerSingleton() {
		if (LazySingletoncreator.SINGLETON != null) {
			throw new RuntimeException("不允许创建对象");
		}
	}

	public static final LazyInnerSingleton getInstance() {
		return LazySingletoncreator.SINGLETON;
	}

	private static class LazySingletoncreator {
		private static final LazyInnerSingleton SINGLETON = new LazyInnerSingleton();
	}
}

8.枚举单例

/**
 * 枚举单例
 * @author a_bo  
 * @date 2020年4月18日 下午9:53:03 
 */
public enum EnumSingleton {
	
	INSTANCE;
	private Object obj;
	
	public Object getData(){
		return obj;
	}
	public void setData(Object data){
		obj = data;
	}
	public static EnumSingleton getInstance(){
		return INSTANCE;
	}
	public static void main(String[] args) {
		EnumSingleton i = EnumSingleton.INSTANCE;
		i.setData(new Object());
		Object o1 = i.getData();
		System.out.println(o1);
	}
}

特点

	1.枚举只能被类加载器加载一次，所以枚举可以保证唯一
	2.枚举不能被反射，反射会抛出异常
	3.枚举在反序列化时会根据类名和类对象找到唯一的一个枚举

9.容器单例

/**
 * 容器单例
 * @author a_bo  
 * @date 2020年4月18日 下午10:40:27 
 */
public class ContainerSingleton {
	
	private static Map<String, Object> containerMap = new ConcurrentHashMap<String,Object>();
	
	public static <T> T getInstance(Class<? extends T> clazz) throws Exception{
		String simpleName = clazz.getSimpleName();
		if (!containerMap.containsKey(simpleName)) {
			T t = clazz.newInstance();
			containerMap.put(simpleName, t);
			return t;
		}
		return (T) containerMap.get(simpleName);
	}
}

总结

	1.线程不安全
	2.适用创建大量对象

9.线程单例

/**
 * 线程单例
 * @author a_bo  
 * @date 2020年4月18日 下午10:57:32 
 */
public class ThreadLocalSingleton {
	
	private static final ThreadLocal<APP> instances = new ThreadLocal<APP>(){

		@Override
		protected APP initialValue() {
			return new APP();
		}
	};
	
	private ThreadLocalSingleton(){
	}
	
	public static APP getInstance(){
		return instances.get();
	}
	public static void main(String[] args) {
		APP a1 = ThreadLocalSingleton.getInstance();
		APP a2 = ThreadLocalSingleton.getInstance();
		System.out.println(a1==a2);//true
	}
}

特点

	1.只能保证在同一个线程下获取到的时单例的对象

10.总结

使用单例模式需要考虑一下几点

	1.线程安全
	2.延迟加载
	3.私有化构造
	4.防止反射破坏单例
	5.防止反序列化破坏单例
	6.针对业务场景选择最佳的单例模式
进击的A_bo
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BlogTest1
zz_itheima的博客
12-12 345
常见数据结构题 SparseArray SparseBooleanArray = HashMap 常见设计模式 单例Builder观察者工厂代理适配器 3种常见的单例写法 饿汉式（静态常量）[可用] public class Singleton { private final static Singleton INSTANCE = new
JAVA设计模式之单例模式
qq_19843217的博客
06-09 992
Java中的设计模式主要分为三种类型：创建型模式、结构型模式和行为型模式。创建型模式关注如何创建对象，旨在解决对象的创建问题，包括单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式等。今天我们详细说说单例模式（Singleton Pattern）。Java单例模式（Singleton Pattern）是一种创建型设计模式，它保证一个类只有一个实例，并提供一个全局访问点。单例模式通常用于需要全局唯一的对象，如线程池、数据库连接池等场景。
JAVA单例模式介绍及使用
低调D树苗的博客
03-16 769
单例模式是一种常见的设计模式，在JAVA中也有多种实现方式。无论使用哪种方式，单例模式的目的都是确保类只有一个实例，并提供全局访问点来访问该实例。我们可以根据实际需要选择合适的单例模式实现方式，并根据需要调整代码以提高性能和线程安全性。
初级必备：单例模式的7个问题
Admans的专栏
08-01 596
单例模式（SingletonPattern）是Java中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。1、单例类只能有一个实例。2、单例类必须自己创建自己的唯一实例。3、单例类必须给所有其他对象提供这一实例4、隐藏所有的构造方法**目的**保证一个类仅有一个实例，并提供一个访问它的全局访问点。...
Java 单例模式详解
兴趣是最好的老师，勤能补拙
05-09 1968
本文介绍了 Java 中所有常见的单例模式实现方式，包括懒汉式、饿汉式、枚举式、双重检查锁定式和静态内部类式。每种实现方式都有其优缺点和适用场景，大家需要根据实际情况进行选择。无论选择哪种实现方式，都应该遵循单一责任原则和开闭原则等设计原则，以确保代码具有良好的可维护性和扩展性。
Java设计模式详解：单例模式
最新发布
Jz_Stu的博客
03-31 1056
通过掌握单例模式的原理、案例和使用场景，我们可以更加灵活地运用它来解决实际开发中的问题。希望这篇文章能够帮助大家更好地理解和应用单例模式，为后续的Java学习和实践打下坚实的基础。
Java 单例模式线程安全问题
08-29
Java 单例模式线程安全问题详解 Java 单例模式线程安全问题是指在 Java 中实现单例模式时，如何确保线程安全的问题。单例模式是指在整个应用程序生命周期中，只有一个实例存在的设计模式。这种模式可以提高性能，...
java单例模式4种使用方式分享
09-04
在Java中，有多种实现单例模式的方式，下面详细介绍四种常见的Java单例模式实现。 1. **静态内部类（SingletonHolder）** 这种方式在《Java Concurrency In Practice》一书中被推荐。其主要优点是线程安全且延迟...
使用Java单例模式实现一个简单的日志记录器.txt
08-17
这段代码实现了一个简单的日志记录器Logger，其中使用了Java的单例模式。在类的构造方法中，首先定义...这个简单的示例代码展示了如何使用Java单例模式来实现一个日志记录器的简单功能，方便了对日志数据的管理和记录。
Java单例模式实现的几种方式
09-01
Java单例模式是一种设计模式，它保证一个类只有一个实例，并提供一个全局访问点。这种模式在需要频繁创建和销毁对象的场景中非常有用，比如配置类、缓存管理或者数据库连接池等。以下是对Java中实现单例模式的几种...
9种Java单例模式详解（推荐）
08-26
Java单例模式是Java编程中的一种设计模式，旨在保证一个类仅有一个实例，并提供一个全局访问点。下面我们将对9种Java单例模式进行详细的介绍。 首先，单例模式的特点是： 1. 一个类只允许产生一个实例化对象。 2....
java中单例模式用法详解
congge
09-14 2550
最近空闲的时候回顾了一下常用的设计模式，其中单例模式是创建型模式中比较基础的一种设计模式，说起单例模式，想必大家并不模式，我们都知道的是，在单例模式下，能够保证一个类只有一个实例对象，就是说，外部访问这个对象的时候，只有一个全局的访问点，究竟里面的原理是什么呢？或许代码很容易看明白，但搞懂里面的原理和思想在开发中可以很方便的转移到其他的开发中，下面结合具体的代码进行说明， 项目结构如下，比较简单...
Java 中单例模式的正确用法？
Thomas.Sir’s Article
03-14 681
单例模式指的是，保证一个类只有一个实例，并且提供一个全局可以访问的入口。 那么我们为什么需要单例呢，其中一个理由，那就是为了节省内存、节省计算。很多情况下，我们只需要一个实例就够了，如果出现了更多的实例，反而属于浪费。举个例子： public class ExpensiveResource { public ExpensiveResource() { field1 = // 查询数据库 field2 = // 然后对查到的数据做大量计算 fiel
单例模式
a329806042的博客
07-28 830
java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 单例模式有以下特点： 1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。 一、懒汉式单例 经典的： //懒汉式单例类.在第一次调用的时候实例化自己 public class Singleton { ...
谁要是再问你单例模式，那就抛给他这7种写法吧！
还没见过大海
04-09 641
单例设计模式是23种设计模式中，最基础也是最常用的设计模式之一，也是面试中关于设计模式知识点考察比较高频的问题之一。说起单例模式的写法，大多数情况下出现在我们脑海中的可能就是“饿汉式”，“懒汉式”这两种写法，但是今天小码哥今天要介绍的是单例模式的7种写法，以后面试官要是再问你单例模式，那就抛给他这七种写法吧！ 接下来，我们就言归正传，来一一介绍这七种单例模式的写法吧！ 1. 饿汉式 饿汉式是单例...
单例模式详解（附常见的7种单例模式源码）
热门推荐
数据知道的博客
05-24 1万+
单例模式（Singleton Pattern）:保证一个类仅有一个对象，并提供一个访问它的全局访问点。(Ensure a class only has one instance,and provide a globe point of access to it.) 常见应用场景： Windows的Task Manager（任务管理器）就是很典型的单例模式 windows的Recycle Bin（......
Java 单例模式四种方式
qq_37980878的博客
07-16 717
一、GetInstance与new getInstance是一个函数，在java中，可以使用这种方式使用单例模式创建类的实例，所谓单例模式就是一个类有且只有一个实例，不像object ob=new object();的这种方式去实例化后去使用。 例: Class A{ Private static A a = null; ...
Java 单例模式使用详解
baipenggui_bo
05-21 247
Java 单例模式使用详解 简述 一个类仅有一个实例，由自己创建并对外提供一个实例获取的入口，外部类可以通过这个入口直接获取该实例对象。 场景 很多时候整个应用只能提供一个全局的对象，为了保证唯一性，这个全局的对象的引用不能再次被更改。比如在某个应用程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例类统一读取并实例化到全局仅...
Java单例模式详解：实现与应用
总结，单例模式在Java编程中有着广泛的应用，选择合适的实现方式取决于项目需求，如是否需要延迟加载、是否考虑线程安全以及代码简洁性等因素。理解并恰当运用单例模式，可以帮助我们优化系统资源，提高程序运行效率...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值