1.单例设计模式介绍
所谓类的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在-一个对象实例,并且该类只提供一个取得其对象实例的方法(静态方法)。比如Hibernate的SessionFactory,它充当数据存储源的代理,并负责创建Session对象。SessionFactory并不 是轻量级的,一般情况下,一个项目通常只需要一个SessionFactory就够,这是就会使用到单例模式。
1.1意图
保证一个类仅有一个实例,并提供一个访问它的全局访问点。
1.2主要解决
一个全局使用的类频繁地创建与销毁。
1.3何时使用
当您想控制实例数目,节省系统资源的时候。
1.4如何解决
判断系统是否已经有这个单例,如果有则返回,如果没有则创建。
1.4关键代码
构造函数是私有的。
1.5 优点和缺点
优点:
- 在内存里只有一个实例,减少了内存的开销,尤其是频繁的创建和销毁实例(比如管理学院首页页面缓存)。
- 避免对资源的多重占用(比如写文件操作)。
缺点: - 没有接口,不能继承,与单一职责原则冲突,一个类应该只关心内部逻辑,而不关心外面怎么样来实例化。
2.单例设计模式八种方式
- 饿汉式(静态常量)
- 饿汉式(静态代码块)
- 懒汉式(线程不安全)
- 懒汉式(线程安全,同步方法)
- 懒汉式(线程安全,同步代码块)(错误示例缺陷大)
- 双重检查(一般推荐)
- 静态内部类(非常推荐)
- 枚举(非常推荐)
2.1 饿汉式(静态常量)
2.1.1实现方式:
package com.xql.designpattern.controller.singleton;
/**
* 饿汉式(静态常量)
*
* @author
* @date 2022/08/16 21:18
**/
public class Singleton01 {
//1.构造器私有化,外部不能直接new获取
private Singleton01() {
}
//2.本类内部创建对象实例
private final static Singleton01 instance= new Singleton01();
//3.提供公有的静态方法,返回实例对象
public static Singleton01 getInstance() {
return instance;
}
}
2.1.2优缺点说明:
2.2饿汉式(静态代码块)
2.2.1实现方式:
package com.xql.designpattern.controller.singleton;
/**
* 饿汉式(静态代码块)
*
* @author
* @date 2022/08/16 21:27
**/
public class Singleton02 {
//1.构造器私有化,外部不能直接new获取
private Singleton02(){
}
//2.本类内部创建对象实例
private static Singleton02 instance;
//3.在静态代码块中 创建单例对象
//静态块用于初始化类,为类的属性初始化。每个静态代码块只会执行一次。
// 静态代码块随着类加载而加载,有多个静态代码块的,按代码块前后顺序加载。
// 由于JVM在加载类时会执行静态代码块,所以静态代码块先于主方法执行。
static {
instance = new Singleton02();
}
//4.提供公有的静态方法,返回实例对象
public static Singleton02 getInstance() {
return instance;
}
}
2.2.2优缺点说明:
2.3懒汉式(线程不安全)
2.3.1实现方式:
package com.xql.designpattern.controller.singleton;
/**
* 懒汉式(线程不安全)
*
* @author
* @date 2022/08/17 08:23
**/
public class Singleton03 {
//1.构造器私有化,外部不能直接new获取
private Singleton03(){
}
//2.本类内部创建对象
private static Singleton03 singleton03;
//3.提供一个静态的公有方法 当第一次使用该方法去创建instance
public static Singleton03 getInstance(){
if (singleton03 == null){
singleton03 = new Singleton03();
}
return singleton03;
}
}
2.3.2优缺点说明:
2.4懒汉式(线程安全,同步方法)
2.4.1实现方式:
package com.xql.designpattern.controller.singleton;
/**
* 懒汉式(线程安全 同步方法)
*
* @author
* @date 2022/08/17 08:32
**/
public class Singleton04 {
//1.构造器私有化,外部不能直接new获取
private Singleton04(){
}
//2.本类内部创建对象
private static Singleton04 singleton04;
//3.提供一个静态的公有方法 当第一次使用该方法去创建instance
public static synchronized Singleton04 getInstance(){
if (singleton04 == null){
singleton04 = new Singleton04();
}
return singleton04;
}
}
2.4.2优缺点说明:
2.5懒汉式(线程安全,同步代码块 错误方式)
2.5.1实现方式:
package com.xql.designpattern.controller.singleton;
/**
* 懒汉式(线程安全 同步代码块 )
*
* @author
* @date 2022/08/17 09:09
**/
public class Singleton05 {
//1.构造器私有化,外部不能直接new获取
private Singleton05(){
}
//2.本类内部创建对象
private static Singleton05 singleton05;
//3.提供一个静态的公有方法 当第一次使用该方法去创建instance
//同步代码块加锁
public static Singleton05 getInstance(){
if (singleton05 == null){
synchronized(Singleton05.class){
singleton05 = new Singleton05();
}
}
return singleton05;
}
}
2.5.2优缺点说明:
2.6双重检查(一般推荐)
2.6.1实现方式:
package com.xql.designpattern.controller.singleton;
/**
* 双重检查
*
* @author
* @date 2022/08/17 09:45
**/
public class Singleton06 {
//1.本类内部创建对象 +volatile
//volatile的作用有三点。
// 1.保证可见性(大概意思就是多线程下每个线程执行完成会去通知主线程)
// 2.不能保证原子性所以加了synchronized。(大家可以去写多线程累加每次+1 发现只加volatile结果不对 不能保证原子性)
// 3.禁止指令重排
private static volatile Singleton06 singleton06;
//1.构造器私有化,外部不能直接new获取
private Singleton06(){
}
//3.提供一个静态的公有方法 当第一次使用该方法去创建instance
//同步代码块加锁
public static Singleton06 getInstance(){
if (singleton06 == null){
synchronized(Singleton06.class){
singleton06 = new Singleton06();
}
}
return singleton06;
}
}
2.6.2优缺点说明:
2.6.3 volatile:
补充:volatile是Java虚拟机提供的轻量级的同步机制,它有3个特性:
- 保证可见性
- 不保证原子性
- 禁止指令重排
详细尽量写在下一篇博客专门说volatile
2.7 静态内部类(非常推荐)
2.7.1实现方式:
package com.xql.designpattern.controller.singleton;
/**
* 静态内部类
*
* @author
* @date 2022/08/17 10:07
**/
public class Singleton07 {
//1.构造器私有化,外部不能直接new获取
private Singleton07(){
}
//静态内部类 该类有一个静态熟悉Singleton07 直在类加载时候执行一次 JVM保证线程安全
private static class SingletonInstance{
private static final Singleton07 INSTANCE = new Singleton07();
}
//3.提供一个静态的公有方法
public static Singleton07 getInstance(){
return SingletonInstance.INSTANCE;
}
}
2.7.2优缺点说明:
2.7.3 静态内部类
2.8 枚举(非常推荐)
2.8.1实现方式:
package com.xql.designpattern.controller.singleton;
/**
* 枚举
*
* @author
* @date 2022/08/17 10:19
**/
public enum Singleton08 {
INSTANCE;
// 使用SingleInstance.INSTANCE.fun1();
public void fun1() {
// do something }
}
}
//测试调用
class Test{
public static void main(String[] args) {
Singleton08 instance = Singleton08.INSTANCE;
Singleton08.INSTANCE.fun1();
}
}
package com.chinagoods.prize.commons.enums;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
/**
* 单例 ProbabilityEnums 可换成单例
*
* @author 许清磊
* @date 2022/08/29 09:55
**/
public enum SingletonProbabilityEnums {
INSTANCE;
private final Map<BigDecimal, Map<Integer,Integer>> map;
SingletonProbabilityEnums() {
map = new HashMap<>();
Map<Integer,Integer> map1 = new HashMap<>();
map1.put(0,2);
map.put(BigDecimal.valueOf(1),map1);
Map<Integer,Integer> map2 = new HashMap<>();
map2.put(2,5);
map.put(BigDecimal.valueOf(8),map2);
Map<Integer,Integer> map3 = new HashMap<>();
map3.put(5,8);
map.put(BigDecimal.valueOf(10),map3);
Map<Integer,Integer> map4 = new HashMap<>();
map4.put(8,11);
map.put(BigDecimal.valueOf(12),map4);
Map<Integer,Integer> map5 = new HashMap<>();
map5.put(11,14);
map.put(BigDecimal.valueOf(14),map5);
Map<Integer,Integer> map6 = new HashMap<>();
map6.put(14,17);
map.put(BigDecimal.valueOf(16),map6);
Map<Integer,Integer> map7 = new HashMap<>();
map7.put(17,20);
map.put(BigDecimal.valueOf(18),map7);
Map<Integer,Integer> map8 = new HashMap<>();
map8.put(20,null);
map.put(BigDecimal.valueOf(20),map8);
}
public static SingletonProbabilityEnums getInstance(){
return INSTANCE;
}
public Map<BigDecimal, Map<Integer, Integer>> getMap() {
return map;
}
}
public enum BitCheck {
INSTANCE;
BitCheck() {
props = new HashMap<String, String>();
}
private final Map<String, String> props;
//..
}
public enum BitCheck {
INSTANCE(new HashMap<String, String>());
BitCheck(final Map<String, String> props) {
this.props = props;
}
public enum BitCheck {
INSTANCE;
private final Map<String, String> props = new ConcurrentHashMap<String, String>();
public void putAll(HashMap<String, String> map) {
props.putAll(map);
}
}
public enum BitCheck {
INSTANCE;
private BitCheck() {
// initialize here
}
}
private static Properties props;
private static AtomicBoolean isInitialized = new AtomicBoolean(false);
public void init(Properties props){
if(isInitialized.compareAndSet(false, true)) {
this.props = props;
}
}
package com.xql.designpattern.controller.singleton;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* 只是举例子只执行一次
*
* @author 许清磊
* @date 2022/08/29 10:35
**/
public enum PrizeFlagEnums {
INSTANCE;
private final AtomicBoolean flag;
PrizeFlagEnums() {
System.out.println("我执行了====================");
flag = new AtomicBoolean(getTaskFlag());
}
public Boolean getFlag() {
return flag.get();
}
private boolean getTaskFlag() {
LocalDateTime start = LocalDateTime.parse("2022-08-26 00:00:00", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));;
LocalDateTime end = LocalDateTime.parse("2022-08-30 23:59:59", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));;
return LocalDateTime.now().isBefore(end)&&LocalDateTime.now().isAfter(start);
}
}
2.8.2优缺点说明:
2.8.3枚举:
3.一些源码用到的单例
3.1 JDK的Runtime(饿汉式 静态常量)
因为很多地方用到Runtime 所以可以在类转载时候去创建一次
3.2 Spring的Bean默认是Singleton
主要是两种配置方式
Spring是借助ConcurrentHashMap来实现单例注册表。Spring 实现单例的核心代码如下:
3.3java.util.logging的Logger
public Logger getParent() {
// Note: this used to be synchronized on treeLock. However, this only
// provided memory semantics, as there was no guarantee that the caller
// would synchronize on treeLock (in fact, there is no way for external
// callers to so synchronize). Therefore, we have made parent volatile
// instead.
return parent;
}
/**
* Set the parent for this Logger. This method is used by
* the LogManager to update a Logger when the namespace changes.
* <p>
* It should not be called from application code.
* <p>
* @param parent the new parent logger
* @throws SecurityException if a security manager exists and if
* the caller does not have LoggingPermission("control").
*/
public void setParent(Logger parent) {
if (parent == null) {
throw new NullPointerException();
}
// check permission for all loggers, including anonymous loggers
if (manager == null) {
manager = LogManager.getLogManager();
}
manager.checkPermission();
doSetParent(parent);
}
// Private method to do the work for parenting a child
// Logger onto a parent logger.
private void doSetParent(Logger newParent) {
// System.err.println("doSetParent \"" + getName() + "\" \""
// + newParent.getName() + "\"");
synchronized (treeLock) {
// Remove ourself from any previous parent.
LogManager.LoggerWeakRef ref = null;
if (parent != null) {
// assert parent.kids != null;
for (Iterator<LogManager.LoggerWeakRef> iter = parent.kids.iterator(); iter.hasNext(); ) {
ref = iter.next();
Logger kid = ref.get();
if (kid == this) {
// ref is used down below to complete the reparenting
iter.remove();
break;
} else {
ref = null;
}
}
// We have now removed ourself from our parents' kids.
}
// Set our new parent.
parent = newParent;
if (parent.kids == null) {
parent.kids = new ArrayList<>(2);
}
if (ref == null) {
// we didn't have a previous parent
ref = manager.new LoggerWeakRef(this);
}
ref.setParentRef(new WeakReference<>(parent));
parent.kids.add(ref);
// As a result of the reparenting, the effective level
// may have changed for us and our children.
updateEffectiveLevel();
}
}
3.4 日常应用
比如 配置类、日志类、数据库、数据库连接池、线程池
4.小结和应用场景
- 单例模式保证了系统内存中该类只存在一一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统性能
- 当想实例化一个单例类的时候,必须要记住使用相应的获取对象的方法,而不是使用new
- 单例模式使用的场景:需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即:重量级对象),但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂 等)