单例设计模式

最新推荐文章于 2023-07-25 20:54:09 发布
最新推荐文章于 2023-07-25 20:54:09 发布
阅读量534 收藏 7
点赞数 2
分类专栏： 单例设计模式 Java 文章标签： java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41911570/article/details/104227340
版权

什么是Singleton?

  • Singleton:在Java中即指单例设计模式，它是软件开发中最常用的设计模式之一。
  • 单：唯一
  • 例：实例
    在这里插入图片描述
  • 单例设计模式，即某个类在整个系统中只能有一个实例对象可被获取和使用的代码模式。
  • 例如： 代码JVM运行环境的Runtime类

要点

  • 一是，某个类只能有一个实例
    构造器私有化
  • 二是，它必须自行创建这个实例
    含有一个该类的静态变量来保存这个唯一的实例
  • 三是，它必须自行向整个系统提供这个实例；
    对外提供获取该实例对象的方式：
    ① 直接暴露； ② 用静态变量的get方法获取
    在这里插入图片描述

几种常见形式

饿汉式

直接创建对象，不存在线程安全问题

直接实例化饿汉式（简洁直观）

package com.single;

/**
 * 饿汉式：
 * 在类初始化时直接创建实例对象，不管你是否需要这个对象都会创建
 * 
 * 
 * (1)、构造器私有化：      private Singleton1() {}
 * (2)、自行创建，并且用静态变量保存：      static Singleton1 INSTANCE = new Singleton1();
 * (3)、向外提供这个实例：     public static Singleton1 INSTANCE = new Singleton1();
 * (4)、强调这是一个单例，我们可以用final修改：    public static final Singleton1 INSTANCE = new Singleton1();
 * @author ouyang
 *
 */
public class Singleton1 {
	public static final Singleton1 INSTANCE = new Singleton1();
	private Singleton1() {
		
	}
}
测试
package com.single;

public class TestSingleton1 {
	public static void main(String[] args) {
		Singleton1 s1 = Singleton1.INSTANCE;
		Singleton1 s2 = Singleton1.INSTANCE;
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s1 == s2);
	}
}

在这里插入图片描述

枚举式（最简洁）

枚举本身就是私有构造方法，并且重写了toString方法为变量名。

package com.single;

/**
 * 饿汉式：
 * 枚举类型：表示该类型的对象是有限的几个
 * 我们可以限定为一个，就成了单例
 * 
 * @author ouyang
 *
 */
public enum Singleton2 {
	INSTANCE
}
测试
package com.single;

public class TestSingleton2 {
	public static void main(String[] args) {
		Singleton2 s1 = Singleton2.INSTANCE;
		Singleton2 s2 = Singleton2.INSTANCE;
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s1 == s2);
	}
}

在这里插入图片描述

静态代码块饿汉式（适合复杂实例化）

当实例对象创建需要参数，并且参数来自配置文件时。
创建一个配置文件 single.properties
注意文件在src下

#key=value
info=singleTest

package com.single;

import java.io.IOException;
import java.util.Properties;

/**
 * 饿汉式：
 * 静态代码块饿汉式（适合复杂实例化）
 * @author ouyang
 *
 */
public class Singleton3 {
	public static final Singleton3 INSTANCE;
	private String info;
	
	static {
		try {
			Properties pro = new Properties();
			pro.load(Singleton3.class.getClassLoader().getResourceAsStream("single.properties"));
			INSTANCE = new Singleton3(pro.getProperty("info"));
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}
	private Singleton3(String info) {
		this.info = info;
	}
	public String getInfo() {
		return info;
	}
	public void setInfo(String info) {
		this.info = info;
	}
	@Override
	public String toString() {
		return "Singleton3 [info=" + info + "]";
	}

}
测试
package com.single;

public class TestSingleton3 {
	public static void main(String[] args) {
		Singleton3 s1 = Singleton3.INSTANCE;
		Singleton3 s2 = Singleton3.INSTANCE;
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s1 == s2);
	}
}

在这里插入图片描述

懒汉式

线程不安全（适用于单线程）

package com.single;

/**
 * 懒汉式：
 * 线程不安全（适用于单线程）
 * 
 * (1)、构造器私有化：      private Singleton4() {}
 * (2)、用静态变量保存这个唯一的实例：      private static Singleton4 instance;
 * (3)、提供一个静态方法，获取这个实例对象：     
 * 	public static Singleton4 getInstance() {
 *		if(instance == null) {
 * 			instance = new Singleton4();
 *		}
 *		return instance;
 *	}
 *
 * 
 * @author ouyang
 *
 */
public class Singleton4 {
	private static Singleton4 instance;
	private Singleton4(){
		
	}
	public static Singleton4 getInstance() {
		if(instance == null) {
			//为了看效果，线程休眠100毫秒
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			instance = new Singleton4();
		}
		return instance;
	}
}
测试
package com.single;

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

在这里插入图片描述

如果是多线程呢？
package com.single;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class TestSingleton4 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		
		Callable<Singleton4> c = new Callable<Singleton4>() {

			@Override
			public Singleton4 call() throws Exception {
				return Singleton4.getInstance();
			}	
		};
		//线程池
		ExecutorService es = Executors.newFixedThreadPool(2);
		Future<Singleton4> f1 = es.submit(c);
		Future<Singleton4> f2 = es.submit(c);
		Singleton4 s1 = f1.get();
		Singleton4 s2 = f2.get();
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s1 == s2);
	}
}

在这里插入图片描述

线程安全（适用于多线程）

package com.single;
/**
 * 懒汉式：
 * 线程安全（适用于多线程）
 * 
 * @author ouyang
 *
 */
public class Singleton5 {
	private static Singleton5 instance;
	private Singleton5(){
		
	}
	public static Singleton5 getInstance() {
		//为了性能多判断一次
		if(instance == null) {
			synchronized (Singleton5.class) {
				if(instance == null) {
					//为了看效果，线程休眠100毫秒
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					instance = new Singleton5();
				}
			}
		}
		return instance;
	}
}
测试
package com.single;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class TestSingleton5 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		
		Callable<Singleton5> c = new Callable<Singleton5>() {
			@Override
			public Singleton5 call() throws Exception {
				return Singleton5.getInstance();
			}	
		};
		//线程池
		ExecutorService es = Executors.newFixedThreadPool(2);
		Future<Singleton5> f1 = es.submit(c);
		Future<Singleton5> f2 = es.submit(c);
		Singleton5 s1 = f1.get();
		Singleton5 s2 = f2.get();
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s1 == s2);
	}
}

在这里插入图片描述

静态内部类形式（适用于多线程）

package com.single;

/**
 * 懒汉式：
 * 静态内部类形式（适用于多线程）
 * 在内部类被加载和初始化时，才创建INSTANCE实例对象
 * 因为静态内部类不会自动随着外部类的加载和初始化而初始化，它是要单独去加载和初始化的。
 * 因为是在内部类加载和初始化时，才创建，因此是线程安全的。
 * @author john
 *
 */
public class Singleton6 {
	
	private Singleton6() {
		
	}
	private static class Inner{
		private static final Singleton6 INSTANCE = new Singleton6();
	}
	
	public static Singleton6 getInstance() {
		return Inner.INSTANCE;
	}
}
测试
package com.single;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class TestSingleton6 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		
		Callable<Singleton6> c = new Callable<Singleton6>() {
			@Override
			public Singleton6 call() throws Exception {
				return Singleton6.getInstance();
			}	
		};
		//线程池
		ExecutorService es = Executors.newFixedThreadPool(2);
		Future<Singleton6> f1 = es.submit(c);
		Future<Singleton6> f2 = es.submit(c);
		Singleton6 s1 = f1.get();
		Singleton6 s2 = f2.get();
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s1 == s2);
	}
}
等我下课
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式之——单例模式
很高兴你能看到这里
06-19 2580
更酷的是，创建对象的职责和管理单例的职责被拆分在两个不同的方法中，这两个方法组合起来才具有单例模式的威力。你学到了吗，少年？
单例模式（单例设计模式）详解
GJ_007的博客
03-31 4万+
在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。 单例模式的定义与特点 单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。 在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程
JAVA设计模式之单例模式
热门推荐
一个本科小生的奋斗史
04-16 99万+
本文继续介绍23种设计模式系列之单例模式。 概念： 　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例...
设计模式||单例模式（含代码样例）
adru的博客
07-25 1021
单例模式（Singleton Pattern）是一种创建型设计模式，它保证一个类只有一个实例，并提供一个全局访问点以供外部代码使用。
java设计模式之单例模式
weixin_44991304的博客
03-16 597
这里写自定义目录标题单例设计模式介绍单例模式应用场景单例设计模式八种方式1.1 饿汉式(静态常量)1.2 饿汉式（静态代码块）1.3懒汉式(线程不安全)1.4懒汉式(线程安全，同步方法)创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 单例设计模式介绍 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并
单例设计模式_单例设计模式_
10-01
单例设计模式是一种在软件工程中广泛使用的设计模式，它的主要目标是确保一个类只有一个实例，并提供一个全局访问点。这种模式在系统中需要频繁创建和销毁对象，且对象需要跨模块共享时特别有用，例如数据库连接、...
单例设计模式实现总结
12-22
单例设计模式是一种常用的设计模式，其主要目的是确保一个类只有一个实例，并且提供全局访问点。这在处理一些需要共享的资源或者全局状态时非常有用，比如日志服务、配置管理或者缓存服务等。单例模式有以下关键点：...
单例设计模式.pdf
07-27
单例设计模式是一种在软件设计中广泛使用的设计模式，它属于创建型模式，其核心目标是确保类只有一个实例，并提供一个全局访问点。这个模式在Java中尤其常见，因为Java的垃圾回收机制允许对象长时间驻留在内存中，...
浅谈java单例设计模式
01-21
所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。 如果我们要让类在一个虚拟机中只能产生一个对象： 将类的构造器的访问...
单例设计模式详解
xxxx1982的博客
06-20 490
单例设计模式详解，思路带入以及代码案例
什么是单例设计模式？
qq_40220357的博客
05-13 1826
什么是单例设计模式？ 单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例 优点 一、实例控制 单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。 二、灵活性 因为类控制了实例化过程，所以类可以灵活更改实例化过程。 缺点 一、开销 虽然数量很少，但如...
Java设计模式—单例设计模式(Singleton Pattern)完全解析
dmk877的专栏
12-16 3万+
认真做好每一件自己下定决心要做的事。
设计模式系列（一）单例模式
robert的专栏
06-05 6830
一、简单介绍 单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例。 《设计模式》书中对单例模式动机的介绍 对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；一个系统只能有一个窗口管理器或文件系统；一个系统只能有一个计时工具或ID(序号)生成器。如在Win
Java四种单例设计模式
八点甜一点
11-20 7747
Java中的四种单例模式单例模式是最容易理解的设计模式之一，介绍Java中单例模式的四种写法。1.饿汉式单例模式public class Singleton{ private static Singleton instance=new Singleton(); private Singleton(){} pulic static Singleton getInstance()
Java的单例设计模式-你看得懂的Java单例设计模式
lds_include
08-01 189
单例设计模式 * 什么是单例设计模式：* 解释：一个类只允许有一个对象，将这个对象做一个全局的访问点，提供出去供大家使用 分析： 用户只能有一个对象 全局的访问点:得到的对象就是全局的访问点. 如何做到全局?让static去修饰 如何提供出去?可以通过单例中的public方法生成 供大家使用?–单例的功能 单例类的作用: 可以实现两个对象之间的传值 可以在全局范围内调用很多的功能. ...
设计模式（一）创建型之单例模式
LeslieGuGu的博客
02-28 304
这里写自定义目录标题1 创建型模式1.1 单例设计模式1.1.1 单例模式的结构1.1.2 单例模式的实现1.1.3 存在的问题1.1.3.1 问题演示1.1.3.2 问题的解决1.1.4 JDK源码解析-Runtime类 1 创建型模式 创建型模式的主要关注点是“怎样创建对象？”，它的主要特点是“将对象的创建与使用分离”。 这样可以降低系统的耦合度，使用者不需要关注对象的创建细节。 创建型模式分为： 单例模式 工厂方法模式 抽象工厂模式 原型模式 建造者模式 1.1 单例设计模式 单例模式（Singl
设计模式之单例
thatkrisyang
04-07 220
单例 单例模式的使用场景 举一个小例子，在我们的windows桌面上，我们打开了一个回收站，当我们试图再次打开一个新的回收站时，Windows系统并不会为你弹出一个新的回收站窗口。，也就是说在整个系统运行的过程中，系统只维护一个回收站的实例。这就是一个典型的单例模式运用。 继续说回收站，我们在实际使用中并不存在需要同时打开两个回收站窗口的必要性。假如我每次创建回收站时都需要消耗大量的资源...
python 单例设计模式
最新发布
03-08
Python的单例设计模式是一种常用的设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取该实例。 在Python中，可以使用以下几种方式来实现单例设计模式： 1. 使用模块：Python的模块是天然的单例，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值