java 单例模式实现方式

最新推荐文章于 2023-08-11 15:42:56 发布
最新推荐文章于 2023-08-11 15:42:56 发布
阅读量311 收藏
点赞数
分类专栏： java编程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hongfenglx/article/details/109007691
版权

一、单例模式优点、注意事项及应用场景

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

二、单例模式实现的几种方式

1. 饿汉式

 代码如下所示：

public class Singleton {
	//1.定义私有化静态的本类单例对象实例。
	private static Singleton instance = null;
 
	/**
	  * 2.构造方法私有化，防止外部类new对象。
	  */
	private Singleton() {
 
	}
 
    //3.提供一个公有的静态方法，返回单例实例对象。
 
	public static Singleton getInstance() {
		if (instance == null) {
			instance = new Singleton();
		}
		return instance;
	}
 
}

 调用顺序时序图如下所示：
在这里插入图片描述
 单例模式的懒汉式体现了缓存的思想，延时加载就是一开始不要加载资源或者数据，一直等，等到马上就要使用这个资源或者数据了，躲不过去了才去加载。懒汉式是典型的时间换空间。

 但是不加同步锁的懒汉式是线程不安全的，如下示例：
在这里插入图片描述
 如何实现线程安全的懒汉式（即双重检查加锁），代码如下所示：

public class Singleton {
    //1.定义私有化静态的本类单例对象实例。
	private volatile static Singleton instance = null;
 
	// 2.构造方法私有化，防止外部类new对象。
	private Singleton() {
 
	}
    //3.提供一个公共的静态方法，返回单例实例对象。
	public static Singleton getInstance() {
		if (instance == null) {//3.1 第一重检查
			synchronized (Singleton.class) {//3.2 加同步锁
				if (instance == null) {//3.3 第二重检查
					instance = new Singleton();
				}
			}
 
		}
		return instance;
	}
 
}

2. 懒汉式

 代码如下所示：

public class Singleton {
    //1.创建一个私有化静态对象。
	private static Singleton instance = new Singleton();
 
	//2.私有化构造方法，防止外部类new对象。
	private Singleton()  
	}
    //3.提供一个公共的静态方法，返回单例实例对象。
	public static Singleton getInstance() {
		return instance;
	}
 
}

 饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要判断了，节省了运行时间。

3.使用静态内部类实现单例模式

 代码如下所示：

public class Singleton {
    //1.私有化静态内部类。
	private static class SingletonHoler {
		/**
		 * 静态初始化器，由JVM来保证线程安全
		 */
		private static Singleton instance = new Singleton();//创建单例实例对象
	}
    //2.私有化单例类构造方法，防止外部类new对象。
	private Singleton() {
	}
    //3.提供一个公共的静态方法，返回单例实例对象。
	public static Singleton getInstance() {
		return SingletonHoler.instance;
	}
 
}

 当getInstance方法第一次被调用的时候,它第一次读取SingletonHolder.instance，导致SingletonHolder类得到初始化；而这个类在装载并被初始化的时候，会初始化它的静态域，从而创建Singleton的实例，由于是静态的域，因此只会在虚拟机装载类的时候初始化一次，并由虚拟机来保证它的线程安全性。

4.使用枚举来实现单例

 代码如下所示：

class Singleton{
}

public enum SingletonEnum {
    INSTANCE;
    private Singleton instance;
    SingletonEnum() {
        instance = new Singleton();
    }
    public Singleton getInstance() {
        return instance;
    }
}

 上面的类Singleton是我们要应用单例模式的资源，具体可以表现为网络连接，数据库连接，线程池等等。获取资源的方式很简单，只要 SingletonEnum.INSTANCE.getInstance() 即可获得所要实例。下面我们来看看单例是如何被保证的：首先，在枚举中我们明确了构造方法限制为私有，在我们访问枚举实例时会执行构造方法，同时每个枚举实例都是static final类型的，也就表明只能被实例化一次。在调用构造方法时，我们的单例被实例化。也就是说，因为enum中的实例被保证只会被实例化一次，所以我们的INSTANCE也被保证实例化一次。可以看到，枚举实现单例还是比较简单的。

5.单例模式在源码中的应用

在这里插入图片描述

三、破坏单例模式的三种方式及解决方法

1.反射机制
2.序列化
3.克隆

 代码如下所示：

/**
 * 序列化对单例的破坏
 * @author Administrator
 *
 */
public class SingletonTest09 {
	
	public static void main(String[] args) throws Exception{
		
		System.out.println("-----------序列化----------------------");
	    Singleton originSingleton = Singleton.getInstance();
	    ByteArrayOutputStream bos = new ByteArrayOutputStream();
	    ObjectOutputStream oos = new ObjectOutputStream(bos);
	    oos.writeObject(Singleton.getInstance());
	    ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
	    ObjectInputStream ois = new ObjectInputStream(bis);
	    Singleton serializeSingleton = (Singleton) ois.readObject();
	    System.out.println(originSingleton == serializeSingleton);//false
	    
	    System.out.println("-----------反射----------------------");
	    //通过反射获取
	    Constructor<Singleton> cons = Singleton.class.getDeclaredConstructor();
	    cons.setAccessible(true);
	    Singleton reflextSingleton = cons.newInstance();
	    System.out.println(reflextSingleton == originSingleton);//false
	    
	    System.out.println("---------------------------克隆----------------------");
	    
	    Singleton cloneSingleton = (Singleton) originSingleton.clone();
	    System.out.println(cloneSingleton == originSingleton);//false
	    
	}
	
	private static class Singleton  implements Serializable,Cloneable{
		//1.定义私有化静态的本类单例对象实例。
		private static  volatile  Singleton instance;
		
		//2.私有化构造方法，防止外部类new对象。
		private Singleton() {}
		
		//3.提供一个公共的静态方法，返回单例实例对象。
		public static  Singleton getInstance() {
			if(instance == null) {
				synchronized (Singleton.class) {
					if(instance == null) {
						instance = new Singleton();
					}
				}
			}
			return instance;
		}
		
		@Override
		protected Object clone() throws CloneNotSupportedException {
		    return super.clone();
		 }
		 
	}
	
}

解决方案如下：

1、防止反射

 定义一个全局变量，当第二次创建的时候抛出异常

2、防止克隆破坏

 重写clone(),直接返回单例对象

3、防止序列化破坏

 添加readResolve(),返回Object对象

代码如下所示：

**
 * 序列化对单例的破坏,解决方案
 * @author Administrator
 *
 */
public class SingletonTest10 {
	
	public static void main(String[] args) throws Exception{
		
		System.out.println("-----------序列化----------------------");
	    Singleton originSingleton = Singleton.getInstance();
	    ByteArrayOutputStream bos = new ByteArrayOutputStream();
	    ObjectOutputStream oos = new ObjectOutputStream(bos);
	    oos.writeObject(Singleton.getInstance());
	    ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
	    ObjectInputStream ois = new ObjectInputStream(bis);
	    Singleton serializeSingleton = (Singleton) ois.readObject();
	    System.out.println(originSingleton == serializeSingleton);//false
	    
	    System.out.println("-----------反射----------------------");
	    //通过反射获取
	    Constructor<Singleton> cons = Singleton.class.getDeclaredConstructor();
	    cons.setAccessible(true);
	    Singleton reflextSingleton = cons.newInstance();
	    System.out.println(reflextSingleton == originSingleton);//false
	    
	    System.out.println("---------------------------克隆----------------------");
	    
	    Singleton cloneSingleton = (Singleton) originSingleton.clone();
	    System.out.println(cloneSingleton == originSingleton);//false
	    
	}
	
	private static class Singleton  implements Serializable,Cloneable{
		
		private static volatile boolean isCreate = false;//全局变量，默认是第一次创建
		
		//1.定义私有化静态的本类单例对象实例。
		private static  volatile  Singleton instance;
		
		//2.私有化构造方法，防止外部类new对象。
		private Singleton() {
			if(isCreate) {
				throw new RuntimeException("已然被实例化一次，不能在实例化");
			}
			isCreate = true;
		}
		
		//3.提供一个公共的静态方法，返回单例实例对象。
		public static  Singleton getInstance() {
			if(instance == null) {
				synchronized (Singleton.class) {
					if(instance == null) {
						instance = new Singleton();
					}
				}
			}
			return instance;
		}
		
		@Override
		 protected Object clone() throws CloneNotSupportedException {
		     return instance;
		 }
		
		/**
		 * 防止序列化破环
		 * @return
		 */
		private Object readResolve() {
	        return instance;
	    }
		 
	}
	
}
hongfenglx
关注
专栏目录
Java创建型设计模式-单例模式
欢迎拜读我的作品，喜欢的领域请给我留言
08-10 1820
好啦，以上就是关于java设计模式的单例模式详细介绍，整理出八种初始化方式及其利弊分析，最佳方式推荐是3.4章节的线程安全单例。
Java 单例模式常见五种实现方式
c1441173216的博客
11-16 1150
单例模式，属于创建类型的一种常用的软件设计模式。”Java中单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。”。饿汉式与懒汉式实现，双检锁，volatile，synchronized，解决线程安全问题
单例模式各种实现方式
03-26
java单例模式的实现方式
实现单例模式的八种方法
weixin_45522644的博客
12-02 1491
一.单例模式的定义： 单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例 二.单例模式的特点 　1、单例类只能有一个实例。　 　2、单例类必须自己创建自己的唯一实例。 　3、单例类必须给所有其他对象提供这一实例。 　 三.线程安全问题： 一方面在获取单例的时候，要保证不能产生多个实例对象，后面会详细讲到五种实现方式； 另一方面，在使用单例对象的时候，要注意单例对象内的实例变量是...
java 单例模式实现的5种方式
qq_49983016的博客
04-12 1682
第一种：饿汉式 /** * Created with IntelliJ IDEA. * * @author: 宸濯 * Date: 2021/08/18 8:21 * Description:单例模式的设计(饿汉式) * 1.构造方法私有化 * 2.在静态语句块实例化 * 3.提供调用实例对象的方法 * 4.空间换时间，不管有没有调用方法，实例都创建了 * Version: V1.0 */ public class SingletonOne { private static
单例模式的几种实现方式
weixin_38120392的博客
09-04 224
~~~java public class SingleObject{// 创建 SingleObject 的一个对象 private static SingleObject instance = new SingleObject(); // 构造函数私有化 private SIngleObject(){} //获取唯一可用的对象 public static SingleObject getIns
5种方式实现 Java 单例模式
热门推荐
weixin_47367099的博客
06-17 1万+
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。是否多线程安全：是是否懒加载：否正如名字含义，饿汉需要直接创建实例。 缺点： 类加载就初始化，浪费内存 优点： 没有加锁，执行效率高。还是线程安全的实例。懒汉单例，在类初始化不会创建实例，只有被调用时
Java单例模式实现的几种方式
09-01
Java单例模式是一种设计模式，它保证一个类只有一个实例，并提供一个全局访问点。这种模式在需要频繁创建和销毁对象的场景中非常有用，比如配置类、缓存管理或者数据库连接池等。以下是对Java中实现单例模式的几种...
Java单例模式实现静态内部类方法示例
08-29
"Java单例模式实现静态内部类方法示例" Java单例模式是软件设计模式中最基本和最常见的一种设计模式，也是最容易理解的一种设计模式。它的主要思想是确保某个类只有一个实例，并且提供一个全局访问点来访问该实例。...
使用Java单例模式实现一个简单的日志记录器.txt
最新发布
08-17
### 使用Java单例模式实现一个简单的日志记录器 #### 一、单例模式简介 单例模式是一种常用的软件设计模式，在该模式中，一个类只能创建一个实例，并且提供了一个全局访问点来访问该实例。单例模式的主要优点包括...
实现单例模式
a447780100的博客
12-14 78
单例模式 单例是设计模式中十分常见的一种，在iOS开发中也会经常用到。 当有多处代码块需要使用同一个对象实例时，单例模式可以保证在程序运行过程,一个类只有一个实例（而且该实例易于供外界访），从而方便地控制了实例个数,节约系统资源 单例的实现 类的alloc方法内部其实调用了allocWithZone:方法。创建一个该类的静态实例,重写此方法，访问时为若静态实例为nil，则调用su...
java 单例模式（5种实现方式）
qq_53844452的博客
08-05 2079
单例模式的五种实现方式
Java单例模式详解（五种实现方式）
qq_64680177的博客
08-11 3892
Java单例模式是一种设计模式，用于确保一个类只有一个实例，并提供全局访问点以获取该实例。它通常用于需要共享资源或控制某些共享状态的情况下。例如：一个日志记录器（Logger）。在一个应用程序中，可能有多个组件需要记录日志，但是我们希望只有一个日志记录器实例来避免重复创建和管理多个日志文件。使用单例模式，我们可以确保只有一个日志记录器实例存在，并且所有组件都可以共享该实例来记录日志。这样可以简化日志记录的管理，并确保日志信息的一致性。
Java 单例模式
wxilin2111的博客
09-24 219
转载自：http://www.race604.com/java-double-checked-singleton/ 单例模式是最简单的设计模式，实现也非常“简单”。一直以为我写没有问题，直到被 Coverity 打脸。 1. 暴露问题 前段时间，有段代码被 Coverity 警告了，简化一下代码如下，为了方便后面分析，我在这里标上了一些序号： private static Settings
Java单例模式实现日志记录器
"该资源提供了一个使用Java单例模式实现的日志记录器示例，名为Logger。这个类确保在整个应用程序中只有一个Logger实例，并且能够安全地写入日志到指定的文件路径。" 在Java编程中，单例模式是一种常用的创建型设计...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值