/** Cache of singleton objects: bean name to bean instance. */
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

	/** Cache of singleton factories: bean name to ObjectFactory. */
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

	/** Cache of early singleton objects: bean name to bean instance. */
	private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

@Service
public class TestService1 {
    @Autowired
    private TestService2 testService2;
    public void test1() {
    }
}

@Service
public class TestService2 {
    @Autowired
    private TestService1 testService1;
    public void test2() {
    }
}

/**
  * Return the (raw) singleton object registered under the given name.
  * <p>Checks already instantiated singletons and also allows for an early
  * reference to a currently created singleton (resolving a circular reference).
  * @param beanName the name of the bean to look for
  * @param allowEarlyReference whether early references should be created or not
  * @return the registered singleton object, or {@code null} if none found
  */
	@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  // Quick check for existing instance without full singleton lock
  Object singletonObject = this.singletonObjects.get(beanName);
  if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
  	singletonObject = this.earlySingletonObjects.get(beanName);
  	if (singletonObject == null && allowEarlyReference) {
    synchronized (this.singletonObjects) {
    	// Consistent creation of early reference within full singleton lock
    	singletonObject = this.singletonObjects.get(beanName);
    	if (singletonObject == null) {
      singletonObject = this.earlySingletonObjects.get(beanName);
      if (singletonObject == null) {
      	ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
      	if (singletonFactory != null) {
        singletonObject = singletonFactory.getObject();
        this.earlySingletonObjects.put(beanName, singletonObject);
        this.singletonFactories.remove(beanName);
      	}
      }
    	}
    }
  	}
  }
  return singletonObject;
	}

/**
  * Obtain a reference for early access to the specified bean,
  * typically for the purpose of resolving a circular reference.
  * @param beanName the name of the bean (for error handling purposes)
  * @param mbd the merged bean definition for the bean
  * @param bean the raw bean instance
  * @return the object to expose as bean reference
  */
	protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
  Object exposedObject = bean;
  if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
  	for (BeanPostProcessor bp : getBeanPostProcessors()) {
    if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
    	SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
    	exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
    }
  	}
  }
  return exposedObject;
	}

@Service
public class TestService1 {
    @Autowired
    private TestService2 testService2;
    @Autowired
    private TestService3 testService3;
    public void test1() {
    }
}
@Service
public class TestService2 {
    @Autowired
    private TestService1 testService1;
    public void test2() {
    }
}
@Service
public class TestService3 {
    @Autowired
    private TestService1 testService1;
    public void test3() {
    }
}

@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Service
public class TestService1 {
    @Autowired
    private TestService2 testService2;
    public void test1() {
    }
}
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Service
public class TestService2 {
    @Autowired
    private TestService1 testService1;
    public void test2() {
    }
}

@Override
	public void preInstantiateSingletons() throws BeansException {
  if (logger.isTraceEnabled()) {
  	logger.trace("Pre-instantiating singletons in " + this);
  }

  // Iterate over a copy to allow for init methods which in turn register new bean definitions.
  // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
  List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

  // Trigger initialization of all non-lazy singleton beans...
  for (String beanName : beanNames) {
  	RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  	if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
    if (isFactoryBean(beanName)) {
    	Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
    	if (bean instanceof FactoryBean) {
      FactoryBean<?> factory = (FactoryBean<?>) bean;
      boolean isEagerInit;
      if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
      	isEagerInit = AccessController.doPrivileged(
        	(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
        	getAccessControlContext());
      }
      else {
      	isEagerInit = (factory instanceof SmartFactoryBean &&
        	((SmartFactoryBean<?>) factory).isEagerInit());
      }
      if (isEagerInit) {
      	getBean(beanName);
      }
    	}
    }
    else {
    	getBean(beanName);
    }
  	}
  }

@Service
public class TestService3 {
    @Autowired
    private TestService1 testService1;
}

Requested bean is currently in creation: Is there an unresolvable circular reference?

@Service
public class TestService1 {
    public TestService1(TestService2 testService2) {
    }
}
@Service
public class TestService2 {
    public TestService2(TestService1 testService1) {
    }
}

Requested bean is currently in creation: Is there an unresolvable circular reference?

@Service
public class TestService1 {
    @Autowired
    private TestService2 testService2;
    @Async
    public void test1() {
    }
}
@Service
public class TestService2 {
    @Autowired
    private TestService1 testService1;
    public void test2() {
    }
}

if (earlySingletonExposure) {
  	Object earlySingletonReference = getSingleton(beanName, false);
  	if (earlySingletonReference != null) {
    if (exposedObject == bean) {
    	exposedObject = earlySingletonReference;
    }
    else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
    	String[] dependentBeans = getDependentBeans(beanName);
    	Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
    	for (String dependentBean : dependentBeans) {
      if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
      	actualDependentBeans.add(dependentBean);
      }
    	}
    	if (!actualDependentBeans.isEmpty()) {
      throw new BeanCurrentlyInCreationException(beanName,
        "Bean with name '" + beanName + "' has been injected into other beans [" +
        StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
        "] in its raw version as part of a circular reference, but has eventually been " +
        "wrapped. This means that said other beans do not use the final version of the " +
        "bean. This is often the result of over-eager type matching - consider using " +
        "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
    	}
    }
  	}
  }

@Service
public class TestService6 {
    @Autowired
    private TestService2 testService2;
    @Async
    public void test1() {
    }
}

@DependsOn(value = "testService2")
@Service
public class TestService1 {
    @Autowired
    private TestService2 testService2;
    public void test1() {
    }
}
@DependsOn(value = "testService1")
@Service
public class TestService2 {
    @Autowired
    private TestService1 testService1;
    public void test2() {
    }
}

Circular depends-on relationship between 'testService2' and 'testService1'

// Guarantee initialization of beans that the current bean depends on.
    String[] dependsOn = mbd.getDependsOn();
    if (dependsOn != null) {
    	for (String dep : dependsOn) {
      if (isDependent(beanName, dep)) {
      	throw new BeanCreationException(mbd.getResourceDescription(), beanName,
        	"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
      }
      registerDependentBean(dep, beanName);
      try {
      	getBean(dep);
      }
      catch (NoSuchBeanDefinitionException ex) {
      	throw new BeanCreationException(mbd.getResourceDescription(), beanName,
        	"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
      }
    	}
    }