6.Spring源码之路-DefaulListableBeanFactory - DefaultSingletonBeanRegistry

DefaultSingletonBeanRegistry总结

1. 这个类继承了SimpleAliasRegistry并且实现了SingletonBeanRegistry，那么说明此类拥有了给Bean起别名以及单例Bean注册的相关功能，此类主要是实现了单例Bean注册的功能
2. 当前单例Bean在注册的时候有几个比较关键的属性来做Bean的生命周期状态的转换
   • singletonObjects保存的是实力化过后的单例Bean
   • singletonFactories保存的是单例的Bean的Bean工厂，在当前成员属性中存在的，肯定在singletonObjects中没有(解决循环依赖，通过它向外暴露)
   • earlySingletonObjects这个成员属性存放的是已经实例化后的Bean对象，但此时还没有完全准备好，不能被外部使用的Bean。(解决循环依赖，通过它向外暴露)
   • registeredSingletons已经注册过的单例Bean的名字的集合
3. 单例Bean实例化过程中，上面的4个成员属性的变化，由如下方法影响:
   • protected void addSingleton(String beanName, Object singletonObject)这个方法是最终将实例化过后并且已经完全就绪的Bean添加到singletonObjects这个成员属性中的方法，并且还会将Bean的名称添加到registeredSingletons中，只要在这两个成员变量中存在，那么此时的Bean就是已经完全就绪，可以使用的Bean，这个方法的实现是可以被多次调用，如果两个Bean的名字一样，后面的Bean会覆盖前面添加进来的Bean。但是这个protected的，应该来说提供给子类注册使用的
   • public void registerSingleton(String beanName, Object singletonObject)这个方法是SingletonBeanRegistry接口中的一个方法，但底层就是调用protected void addSingleton(String beanName, Object singletonObject)这个方法，只不过这里面做了个判断，就是如果相同的Bean名称已经注册过了，那么这里就会抛出异常
   • protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory)这个方法是注册一个ObjectFactory对象，他会将Bean的名称和ObjectFactory对象存入到singletonFactories这个成员属性中，并且也会向registeredSingletons这个成员属性中将Bean的名称加入进去。
     • 先说下循环依赖的问题，比如说，如果我们当前正在创建一个BeanA，BeanA已经实例化结束了，那么这个时候，他里面有需要自动注入BeanB这个对象，这个时候又去实例化需要注入的BeanB，在实例化完BeanB以后，BeanB又需要注入的BeanA，这个时候BeanA和BeanB就产生了循环依赖的问题。
     • spring的解决方案，当在容器中获取BeanA的时候，会先去singletonObjects中找，没有，再去earlySingletonObjects里面找，没有，再去singletonFactories里面找，这个里面也没有，那么这个时候开始创建实例化BeanA，实例化完毕后，判断如果当前BeanA正在创建，会调用这个方法将当前已经实例化过但是还没有完全准备完毕的BeanA通过ObjectFactory接口的getObject()方法包装，调用protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory)方法将这个对象存到singletonFactories这个属性中，然后开始进行属性装配或者是实例化依赖的对象，假如这时候BeanA依赖于BeanB，这个时候会去容器中获取BeanB，BeanB会执行相同的过程，会先去singletonObjects中找，没有，然后去earlySingletonObjects中找，还没有，再去singletonFactories里面找，找到以后就调用getObject()方法获取到BeanA对象，然后会删除singletonFactories中的BeanA的ObjectFactory，将获取到的BeanA对象引用存入earlySingletonObjects中，并返回BeanA对象引用，这个时候就会将已经实例化但是还没有完全准备好的BeanA注入进来，等BeanB完全准备好以后，再将BeanB注入到BeanA中，这样就解决了循环依赖的问题
     • 上述的创建Bean前的查找过程，就是调用了当前类的public Object getSingleton(String beanName)，这个方法又调用了protected Object getSingleton(String beanName, boolean allowEarlyReference)，这个方法里面就是上面的查找的逻辑。
   • 上面操作只要是注册或者添加，都会向registeredSingletons这个成员属性写入数据，则它保存的是所有单例Bean的名称，不管是初始化好还是没有初始化好的。
   • 获取单例Bean的入口方法是public Object getSingleton(String beanName, ObjectFactory singletonFactory)，如果子类要获取单例的Bean则需要调用这个方法，因为这个方法里面有保存，对象在创建过程中的状态。例如：上面说的解决循环依赖的问题的时候，判断BeanA是否正在创建public boolean isSingletonCurrentlyInCreation(String beanName)的方法，其实是判断当前类中的singletonsCurrentlyInCreation这个成员属性的集合中是否包含BeanA这个名字，BeanA这个名字就是在public Object getSingleton(String beanName, ObjectFactory singletonFactory)这个入口方法中添加的

源码注释的大概翻译

/**
 * 共享bean实例的通用注册表，实现
 * {@link org.springframework.beans.factory.config.SingletonBeanRegistry}。 
 * 允许注册应该由bean名称获得的所有注册表调用者共享的单例实例。 
 * 还支持 {@link org.springframework.beans.factory.DisposableBean}实例
 * （可能对应 或可能不对应已注册的单例）的注册，在注册表关闭时销毁。
 * 可以注册 bean 之间的依赖关系以强制执行适当的关闭命令。 
 *
 * 此类主要用作{@link org.springframework.beans.factory.BeanFactory}
 * 实现的基类，从而排除了单例bean实例的常见管理。请注意，
 * {@link org.springframework.beans.factory.config.ConfigurableBeanFactory}
 * 接口扩展了{@link SingletonBeanRegistry}接口。 
 * 
 * 请注意，与{{link AbstractBeanFactory}和{@link DefaultListableBeanFactory} 
 * （从其继承）相比，该类既不假设beanDefinition概念也不为bean实例指定创建过
 * 程。也可以用作委托的嵌套助手。 
 * @author Juergen Hoeller
 * @since 2.0
 * @see #registerSingleton
 * @see #registerDisposableBean
 * @see org.springframework.beans.factory.DisposableBean
 * @see org.springframework.beans.factory.config.ConfigurableBeanFactory
 */
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

	/ **要保留的最大抑制异常数。 * /
	private static final int SUPPRESSED_EXCEPTIONS_LIMIT = 100;


	/ **单例对象的缓存：bean名称到bean实例。 * /
	private final Map singletonObjects = new ConcurrentHashMap<>(256);

	/ **单例工厂的高速缓存：Bean名称为ObjectFactory。 * /
	private final Map> singletonFactories = new HashMap<>(16);

	/ **早期的单例对象的高速缓存：bean名称到bean实例。 * /
	private final Map earlySingletonObjects = new HashMap<>(16);

	/ **已注册的单例集，按注册顺序包含Bean名称。 * /
	private final Set registeredSingletons = new LinkedHashSet<>(256);

	/ **当前正在创建的bean的名称。 * /
	private final Set singletonsCurrentlyInCreation =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));

	/ **当前在创建检查中排除的bean名称。 * /
	private final Set inCreationCheckExclusions =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));

	/ **收集抑制的异常，可用于关联相关原因。 * /
	@Nullable
	private Set suppressedExceptions;

	/ **标志，指示我们当前是否在destroySingletons中。 * /
	private boolean singletonsCurrentlyInDestruction = false;

	/ ** 需要被销毁bean实例：Bean名称到Bean实例。 * /
	private final Map disposableBeans = new LinkedHashMap<>();

	/ **在包含的bean名称之间映射：bean name到bean包含的bean名称集。 * /
	private final Map> containedBeanMap = new ConcurrentHashMap<>(16);

	/ **在依赖bean名称之间映射：bean name到相关bean名称的集合。 * /
	private final Map> dependentBeanMap = new ConcurrentHashMap<>(64);

	/ **在相关的Bean名称之间映射：Bean名称到Bean依赖项的Bean名称集。 * /
	private final Map> dependenciesForBeanMap = new ConcurrentHashMap<>(64);


	@Override
	public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
		Assert.notNull(beanName, "Bean name must not be null");
		Assert.notNull(singletonObject, "Singleton object must not be null");
		synchronized (this.singletonObjects) {
			Object oldObject = this.singletonObjects.get(beanName);
			if (oldObject != null) {
				throw new IllegalStateException("Could not register object [" + singletonObject +
						"] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");
			}
			addSingleton(beanName, singletonObject);
		}
	}

	/**
	 * 将给定的单例对象添加到该工厂的单例缓存中。 
	 * 被要求进行单例的Bean的登记。
	 * @param beanName Bean的名称
	 * @param singletonObject 单例Bean的实例
	 */
	protected void addSingleton(String beanName, Object singletonObject) {
		// ***** 这里添加单例Bean的时候 跟当前Bean相关的状态容器需要同步更新 ****
		synchronized (this.singletonObjects) {
			this.singletonObjects.put(beanName, singletonObject);
			this.singletonFactories.remove(beanName);
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.add(beanName);
		}
	}

	/**
	 * 如有必要，添加给定的单例工厂以构建指定的单例。
	 * 被要求进行单身者的紧急注册，例如能够解析循环引用。 
	 * resolve circular references.
	 * @param beanName Bean的名称
	 * @param singletonFactory 创建单例Bean的工厂
	 */
	protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory) {
		Assert.notNull(singletonFactory, "Singleton factory must not be null");
		synchronized (this.singletonObjects) {
			if (!this.singletonObjects.containsKey(beanName)) {
				this.singletonFactories.put(beanName, singletonFactory);
				this.earlySingletonObjects.remove(beanName);
				this.registeredSingletons.add(beanName);
			}
		}
	}

	@Override
	@Nullable
	public Object getSingleton(String beanName) {
		return getSingleton(beanName, true);
	}

	/**
	 * 返回以给定名称注册的（原始）单例对象。 
	 * <检查已经实例化的单例，并且还允许对当前创建的单例的早期引用（解析循环引用）。 
	 * @param beanName 要查找的bean的名称
	 * @param allowEarlyReference 是否应创建早期引用
	 * @return 返回注册的单例对象，如果找不到则返回{@code null} 
	 */
	@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
				singletonObject = this.earlySingletonObjects.get(beanName);
				if (singletonObject == null && allowEarlyReference) {
					ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						singletonObject = singletonFactory.getObject();
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return singletonObject;
	}

	/**
	 * 返回以给定名称注册的（原始）单例对象，
	 * 如果尚未注册，则创建并注册一个新对象。 
	 * @param beanName bean的名称
	 * @param singletonFactory 如果有必要的话，要懒惰地创建单例的ObjectFactory 
	 * @return 返回注册的单例对象
	 */
	public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
		Assert.notNull(beanName, "Bean name must not be null");
		synchronized (this.singletonObjects) {
			Object singletonObject = this.singletonObjects.get(beanName);
			if (singletonObject == null) {
				if (this.singletonsCurrentlyInDestruction) {
					throw new BeanCreationNotAllowedException(beanName,
							"Singleton bean creation not allowed while singletons of this factory are in destruction " +
							"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
				}
				beforeSingletonCreation(beanName);
				boolean newSingleton = false;
				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = new LinkedHashSet<>();
				}
				try {
					singletonObject = singletonFactory.getObject();
					newSingleton = true;
				}
				catch (IllegalStateException ex) {
					// Has the singleton object implicitly appeared in the meantime ->
					// if yes, proceed with it since the exception indicates that state.
					singletonObject = this.singletonObjects.get(beanName);
					if (singletonObject == null) {
						throw ex;
					}
				}
				catch (BeanCreationException ex) {
					if (recordSuppressedExceptions) {
						for (Exception suppressedException : this.suppressedExceptions) {
							ex.addRelatedCause(suppressedException);
						}
					}
					throw ex;
				}
				finally {
					if (recordSuppressedExceptions) {
						this.suppressedExceptions = null;
					}
					afterSingletonCreation(beanName);
				}
				if (newSingleton) {
					addSingleton(beanName, singletonObject);
				}
			}
			return singletonObject;
		}
	}

	/**
	 * 注册一个在创建单例bean实例期间碰巧被抑制的异常，例如临时循环参考解析问题。 
	 * 默认实现保留此注册表的抑制异常集合中的任何给定异常，最多100个异常，并将它
	 * 们作为相关原因添加到最终的顶级{@link BeanCreationException}中。 
	 * @param ex 表示要注册的异常
	 * @see BeanCreationException#getRelatedCauses()
	 */
	protected void onSuppressedException(Exception ex) {
		synchronized (this.singletonObjects) {
			if (this.suppressedExceptions != null && this.suppressedExceptions.size() < SUPPRESSED_EXCEPTIONS_LIMIT) {
				this.suppressedExceptions.add(ex);
			}
		}
	}

	/**
	 * 从该工厂的单例缓存中删除具有给定名称的Bean，
	 * 如果创建失败，则能够清理急于注册的单例。 
	 * @param beanName bean的名称
	 * @see #getSingletonMutex()
	 */
	protected void removeSingleton(String beanName) {
		synchronized (this.singletonObjects) {
			this.singletonObjects.remove(beanName);
			this.singletonFactories.remove(beanName);
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.remove(beanName);
		}
	}

	@Override
	public boolean containsSingleton(String beanName) {
		return this.singletonObjects.containsKey(beanName);
	}

	@Override
	public String[] getSingletonNames() {
		synchronized (this.singletonObjects) {
			return StringUtils.toStringArray(this.registeredSingletons);
		}
	}

	@Override
	public int getSingletonCount() {
		synchronized (this.singletonObjects) {
			return this.registeredSingletons.size();
		}
	}


	public void setCurrentlyInCreation(String beanName, boolean inCreation) {
		Assert.notNull(beanName, "Bean name must not be null");
		if (!inCreation) {
			this.inCreationCheckExclusions.add(beanName);
		}
		else {
			this.inCreationCheckExclusions.remove(beanName);
		}
	}

	public boolean isCurrentlyInCreation(String beanName) {
		Assert.notNull(beanName, "Bean name must not be null");
		return (!this.inCreationCheckExclusions.contains(beanName) && isActuallyInCreation(beanName));
	}

	protected boolean isActuallyInCreation(String beanName) {
		return isSingletonCurrentlyInCreation(beanName);
	}

	/**
	 * 返回指定的单例bean当前是否在创建中在整个工厂内）
	 * @param beanName bean的名称
	 */
	public boolean isSingletonCurrentlyInCreation(String beanName) {
		return this.singletonsCurrentlyInCreation.contains(beanName);
	}

	/**
	 * 创建单例之前的回调。默认实现将单例注册为当前正在创建中。 
	 * @param beanName 要创建的单例的名称
	 * @see #isSingletonCurrentlyInCreation
	 */
	protected void beforeSingletonCreation(String beanName) {
		if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}
	}

	/**
	 * 创建单例后的回调。 
	 * 默认实现将单例标记为不在创建中。 
	 * @param beanName 已创建的单例的名称
	 * @see #isSingletonCurrentlyInCreation
	 */
	protected void afterSingletonCreation(String beanName) {
		if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
			throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
		}
	}


	/**
	 * 将给定的bean添加到此注册表中的disposableBeans列表中。 
	 * DisposableBean通常对应于注册的单例，匹配Bean名称，但可能是不同的实例
	 * 有一个适配类DisposableBeanAdapter，该Bean实例可以不直接实现DisposableBean接口
	 * 通过对DisposableBeanAdapte适配器模式，间接的实现DisposableBean接口
	 * @param beanName bean的名称
	 * @param bean bean的实例
	 */
	public void registerDisposableBean(String beanName, DisposableBean bean) {
		synchronized (this.disposableBeans) {
			this.disposableBeans.put(beanName, bean);
		}
	}

	/**
	 * 在两个bean之间注册一个包含关系，例如在内部bean及其包含的外部bean之间。 
	 * 还根据破坏顺序将包含的bean注册为依赖于包含的bean。
	 * @param containedBeanName 包含的（内部）bean的名称
	 * @param containingBeanName 包含的（外部）bean的名称
	 * @see #registerDependentBean
	 */
	public void registerContainedBean(String containedBeanName, String containingBeanName) {
		synchronized (this.containedBeanMap) {
			Set containedBeans =
					this.containedBeanMap.computeIfAbsent(containingBeanName, k -> new LinkedHashSet<>(8));
			if (!containedBeans.add(containedBeanName)) {
				return;
			}
		}
		registerDependentBean(containedBeanName, containingBeanName);
	}

	/**
	 * 为给定的bean注册一个依赖的bean，
	 * 在给定的bean被销毁之前被销毁。 
	 * @param beanName bean的名称
	 * @param dependentBeanName 依赖的bean的名称
	 */
	public void registerDependentBean(String beanName, String dependentBeanName) {
		String canonicalName = canonicalName(beanName);

		synchronized (this.dependentBeanMap) {
			Set dependentBeans =
					this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
			if (!dependentBeans.add(dependentBeanName)) {
				return;
			}
		}

		synchronized (this.dependenciesForBeanMap) {
			Set dependenciesForBean =
					this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
			dependenciesForBean.add(canonicalName);
		}
	}

	/**
	 * 确定是否已将指定的依赖bean注册为依赖于给定bean或其任何传递依赖项。
	 * 简单的就是说判断给定的beanName 是否依赖于给定的dependentBeanName
	 * @param beanName 要检查的bean的名称
	 * @param dependentBeanName 依赖的bean的名称
	 * @since 4.0
	 */
	protected boolean isDependent(String beanName, String dependentBeanName) {
		synchronized (this.dependentBeanMap) {
			return isDependent(beanName, dependentBeanName, null);
		}
	}

	private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set alreadySeen) {
		if (alreadySeen != null && alreadySeen.contains(beanName)) {
			return false;
		}
		String canonicalName = canonicalName(beanName);
		Set dependentBeans = this.dependentBeanMap.get(canonicalName);
		if (dependentBeans == null) {
			return false;
		}
		if (dependentBeans.contains(dependentBeanName)) {
			return true;
		}
		for (String transitiveDependency : dependentBeans) {
			if (alreadySeen == null) {
				alreadySeen = new HashSet<>();
			}
			alreadySeen.add(beanName);
			if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 确定是否已为给定名称的Bean注册了依赖bean。 
	 * @param beanName 要检查的bean的名称
	 */
	protected boolean hasDependentBean(String beanName) {
		return this.dependentBeanMap.containsKey(beanName);
	}

	/**
	 * 如果有依赖的Bean，则返回依赖于指定bean的所有bean的名称。 
	 * @param beanName bean的名称
	 * @return 返回依赖的bean名称的数组，如果没有则为空数组
	 */
	public String[] getDependentBeans(String beanName) {
		Set dependentBeans = this.dependentBeanMap.get(beanName);
		if (dependentBeans == null) {
			return new String[0];
		}
		synchronized (this.dependentBeanMap) {
			return StringUtils.toStringArray(dependentBeans);
		}
	}

	/**
	 * 如果有依赖的Bean，返回指定bean所依赖的所有bean的名称。 
	 * @param beanName bean的名称
	 * @return 返回bean所依赖的bean的名称数组，如果没有则为空数组
	 */
	public String[] getDependenciesForBean(String beanName) {
		Set dependenciesForBean = this.dependenciesForBeanMap.get(beanName);
		if (dependenciesForBean == null) {
			return new String[0];
		}
		synchronized (this.dependenciesForBeanMap) {
			return StringUtils.toStringArray(dependenciesForBean);
		}
	}

	public void destroySingletons() {
		if (logger.isTraceEnabled()) {
			logger.trace("Destroying singletons in " + this);
		}
		synchronized (this.singletonObjects) {
			this.singletonsCurrentlyInDestruction = true;
		}

		String[] disposableBeanNames;
		synchronized (this.disposableBeans) {
			disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
		}
		for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
			destroySingleton(disposableBeanNames[i]);
		}

		this.containedBeanMap.clear();
		this.dependentBeanMap.clear();
		this.dependenciesForBeanMap.clear();

		clearSingletonCache();
	}

	/**
	 * 清除此注册表中的所有缓存的单例实例
	 * @since 4.3.15
	 */
	protected void clearSingletonCache() {
		synchronized (this.singletonObjects) {
			this.singletonObjects.clear();
			this.singletonFactories.clear();
			this.earlySingletonObjects.clear();
			this.registeredSingletons.clear();
			this.singletonsCurrentlyInDestruction = false;
		}
	}

	/**
	 * 销毁给定的bean。如果找到相应的单例的Bean实例，则委托给
	 * {@code destroyBean} 
	 * @param beanName bean的名称
	 * @see #destroyBean
	 */
	public void destroySingleton(String beanName) {
		// Remove a registered singleton of the given name, if any.
		removeSingleton(beanName);

		// Destroy the corresponding DisposableBean instance.
		DisposableBean disposableBean;
		synchronized (this.disposableBeans) {
			disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
		}
		destroyBean(beanName, disposableBean);
	}

	/**
	 * 销毁给定的bean。必须先销毁依赖于给定bean的bean，
	 * 然后再销毁bean。不应抛出任何异常。 
	 * @param beanName bean的名称
	 * @param bean 要销毁的bean实例
	 */
	protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
		// Trigger destruction of dependent beans first...
		Set dependencies;
		synchronized (this.dependentBeanMap) {
			// Within full synchronization in order to guarantee a disconnected Set
			dependencies = this.dependentBeanMap.remove(beanName);
		}
		if (dependencies != null) {
			if (logger.isTraceEnabled()) {
				logger.trace("Retrieved dependent beans for bean '" + beanName + "': " + dependencies);
			}
			for (String dependentBeanName : dependencies) {
				destroySingleton(dependentBeanName);
			}
		}

		// Actually destroy the bean now...
		if (bean != null) {
			try {
				bean.destroy();
			}
			catch (Throwable ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Destruction of bean with name '" + beanName + "' threw an exception", ex);
				}
			}
		}

		// Trigger destruction of contained beans...
		Set containedBeans;
		synchronized (this.containedBeanMap) {
			// Within full synchronization in order to guarantee a disconnected Set
			containedBeans = this.containedBeanMap.remove(beanName);
		}
		if (containedBeans != null) {
			for (String containedBeanName : containedBeans) {
				destroySingleton(containedBeanName);
			}
		}

		// Remove destroyed bean from other beans' dependencies.
		synchronized (this.dependentBeanMap) {
			for (Iterator>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) {
				Map.Entry> entry = it.next();
				Set dependenciesToClean = entry.getValue();
				dependenciesToClean.remove(beanName);
				if (dependenciesToClean.isEmpty()) {
					it.remove();
				}
			}
		}

		// Remove destroyed bean's prepared dependency information.
		this.dependenciesForBeanMap.remove(beanName);
	}

	/**
	 * 将单例互斥对象公开给子类和外部协作者。 
	 * 如果子类执行任何扩展的单例创建阶段，则它们应在给定的对象上同步。
	 * 特别要注意的是，子类不应该具有自己的互斥体，以创建单例，以避免在
	 * 惰性初始化情况下出现死锁的可能性。
	 */
	@Override
	public final Object getSingletonMutex() {
		return this.singletonObjects;
	}

}