public class PersonA { 
  @Autowired
  private PersonB personB;
}

public class PersonB {
  @Autowired
  private PersonA personA;
}

/** 一級緩存 */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
/** 二級緩存 */ 
private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16); 
/** 三級緩存 */ 
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);

protected <T> T doGetBean( String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
  // 獲取bean的規范名稱
  String beanName = transformedBeanName(name); 
  Object bean;  
  // 從各級緩存中獲取bean對象 
  Object sharedInstance = getSingleton(beanName); 
  // 跟factoryBean相關判斷
  if (sharedInstance != null && args == null) { 
...
  } 
  // 獲取factorybean的真是bean
  //若為普通bean則直接返回對象

  bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); 
} 
...... 
  // 創建單利bean對象 
  if (mbd.isSingleton()) { 
    sharedInstance = getSingleton(beanName, () -> { 
  try {
    // 創建bean
    return createBean(beanName, mbd, args); 
  } catch (BeansException ex) { 
    // Explicitly remove instance from singleton cache: It might have been put there 
    // eagerly by the creation process, to allow for circular reference resolution. 
    // Also remove any beans that received a temporary reference to the bean. destroySingleton(beanName); 
    throw ex; 
  } 
}); 
  bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); 
} 
......    
// 返回bean對象 return (T) bean; }

// 這個方法主要是三級緩存容器，思路大概是：從一級緩存查詢，若找不到去二級緩存查詢，還是不存在則去三級緩存，若三級緩存找到了，則將bean放入二級緩存中
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  // 從一級緩存中查找bean
  Object singletonObject = this.singletonObjects.get(beanName);
  // 判斷一級緩存查找不到bean && bean是否處于創建中，成立，則進入循環依賴
  if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
    synchronized (this.singletonObjects) {
    // 從二級緩存中查找
    singletonObject = this.earlySingletonObjects.get(beanName);
    // 二級緩存未查詢到 && 是否允許獲取早期引用
    if (singletonObject == null && allowEarlyReference) {
      // 從三級緩存查詢
      ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
      // 三級緩存存在bean
      if (singletonFactory != null) {
        // 獲取bean實例
        singletonObject = singletonFactory.getObject();
        // 從三級緩存升級到二級緩存，
        this.earlySingletonObjects.put(beanName, singletonObject);
        // 三級緩存中移除
        this.singletonFactories.remove(beanName);
        }
      }
    }
  }
   // 返回bean
  return singletonObject;
}

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {  
  Assert.notNull(beanName, "Bean name must not be null");  
  synchronized (this.singletonObjects) {        
  // 從一級緩存中獲取對應bean 
  Object singletonObject = this.singletonObjects.get(beanName);      
  // 若bean不存在 
  if (singletonObject == null) {  
    // 當前正在銷毀bean，不能創建
    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){  
      // 執行getObject方法創建bean
      singletonObject = this.singletonObjects.get(beanName);  
      if (singletonObject == null) {  
        throw ex;  
      }  
    } catch(BeanCreationException ex){  
      if (recordSuppressedExceptions) {  
        or (Exception suppressedException : this.suppressedExceptions) { 
          ex.addRelatedCause(suppressedException);  
      }  
    }  
      throw ex;  
    } finally{  
      if (recordSuppressedExceptions) {  
        this.suppressedExceptions = null;  
      } 
      // 單例bean創建完成后，容器移除bean
      afterSingletonCreation(beanName);  
    }  
    // newSingleton為true時，表示bean創建成功  
    // 判斷是否為新的完成整bean
    if (newSingleton) {            
      // 將bean存入一級緩存中
      addSingleton(beanName, singletonObject);  
    }  
   } 
   return singletonObject;  
  }  
}

// 將bean放入一級緩存切清楚二級、三級緩存
protected void addSingleton(String beanName, Object singletonObject) {
  synchronized (this.singletonObjects) {xw
    // 添加到一級緩存中 
    this.singletonObjects.put(beanName, singletonObject); 
    // 從三級緩存中移除 
    this.singletonFactories.remove(beanName);
    // 從二級緩存中移除 
    this.earlySingletonObjects.remove(beanName);
    // 放入已注冊的單利池中
    this.registeredSingletons.add(beanName);
  }
}

// 添加到三級緩存
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
  synchronized (this.singletonObjects) {
  // 若一級緩存不存在bean實例
  if (!this.singletonObjects.containsKey(beanName)) {
    // 添加到三級緩存
    this.singletonFactories.put(beanName, singletonFactory);
    // 從第二級緩存刪除
    this.earlySingletonObjects.remove(beanName);
    // 放入已注冊的單例池里
    this.registeredSingletons.add(beanName);
  }
}