3.3 Spring5源碼---循環依賴過程當中spring讀取不完整bean的最終解決方案

時間 2020-11-15

標籤 html ios spring 緩存多線程併發 app ide 函數源碼分析欄目 Spring 简体版

原文原文鏈接

根據以前解析的循環依賴的源碼, 分析了一級緩存,二級緩存,三級緩存的做用以及如何解決循環依賴的. 然而在多線程的狀況下, Spring在建立bean的過程當中, 可能會讀取到不完整的bean. 下面, 咱們就來研究兩點:

1. 爲何會讀取到不完整的bean.

2. 如何解決讀取到不完整bean的問題.

和本文相關的spring循環依賴的前兩篇博文以下: html

3.1 spring5源碼系列--循環依賴之手寫代碼模擬spring循環依賴ios

3.2spring源碼系列----循環依賴源碼分析spring

一. 爲何會讀取到不完整的bean.

咱們知道, 若是spring容器已經加載完了, 那麼確定全部bean都是完整的了, 但若是, spring沒有加載完, 在加載的過程當中, 構建bean就有可能出現不完整bean的狀況緩存

以下所示: 多線程

首先, 有一個線程要去建立A類, 調用getBean(A),他會怎麼作呢?併發

第一步: 調用getSingleton()方法, 去緩存中取數據, 咱們發現緩存中啥都沒有, 確定返回null. app

第二步: 將其放入到正在建立集合中,標記當前bean A正在建立ide

第三步: 實例化bean函數

第四步: 將bean放到三級緩存中. 定義一個函數接口, 方便後面調用源碼分析

addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

第四步: 屬性賦值. 在屬性賦值的時候, 返現要加載類B,就在這個時候, 另外一個線程也進來了, 要建立Bean A.

第五步: 線程2 建立bean ,也是先去調用getSinglton()從緩存中取, 一二級換粗中都沒有,可是三級緩存中倒是有的. 因而就調用動態代理, 去建立bean, 很顯然這時候建立的bean是不完整的. 而後將其放入到二級緩存中, 二級緩存裏的bean也是不完整的. 這就致使了後面是用的bean可能都是不完整的. 詳細的分析上圖

二. 如何解決讀取到不完整bean的問題.

其實, 之因此出現這樣的問題, 緣由就在於, 第一個bean尚未被建立完, 第二個bean就開始了. 這是典型的併發問題.

針對這個問題, 其實,咱們加鎖就能夠了.

用本身手寫的代碼爲例

第一: 將整個建立過程加一把鎖

/**
     * 獲取bean, 根據beanName獲取
     */
    public static Object getBean(String beanName) throws Exception {

        // 增長一個出口. 判斷實體類是否已經被加載過了
        Object singleton = getSingleton(beanName);
        if (singleton != null) {
            return singleton;
        }
        Object instanceBean;
        synchronized (singletonObjects) { // 標記bean正在建立
            if (!singletonsCurrectlyInCreation.contains(beanName)) {
                singletonsCurrectlyInCreation.add(beanName);
            }

            /**
             * 第一步: 實例化
             * 咱們這裏是模擬, 採用反射的方式進行實例化. 調用的也是最簡單的無參構造函數
             */
            RootBeanDefinition beanDefinition = (RootBeanDefinition) beanDefinitionMap.get(beanName);
            Class<?> beanClass = beanDefinition.getBeanClass();
            // 調用無參的構造函數進行實例化
            instanceBean = beanClass.newInstance();


            /**
             * 第二步: 放入到三級緩存
             * 每一次createBean都會將其放入到三級緩存中. getObject是一個鉤子方法. 在這裏不會被調用.
             * 何時被調用呢?
             * 在getSingleton()從三級緩存中取數據, 調用建立動態代理的時候
             */
            singletonFactories.put(beanName, new ObjectFactory() {
                @Override
                public Object getObject() throws BeansException {
                    return new JdkProxyBeanPostProcessor().getEarlyBeanReference(earlySingletonObjects.get(beanName), beanName);
                }
            });
            //earlySingletonObjects.put(beanName, instanceBean);

            /**
             *  第三步: 屬性賦值
             *  instanceA這類類裏面有一個屬性, InstanceB. 因此, 先拿到 instanceB, 而後在判斷屬性頭上有沒有Autowired註解.
             *  注意: 這裏咱們只是判斷有沒有Autowired註解. spring中還會判斷有沒有@Resource註解. @Resource註解還有兩種方式, 一種是name, 一種是type
             */
            Field[] declaredFields = beanClass.getDeclaredFields();
            for (Field declaredField : declaredFields) {
                // 判斷每個屬性是否有@Autowired註解
                Autowired annotation = declaredField.getAnnotation(Autowired.class);
                if (annotation != null) {
                    // 設置這個屬性是可訪問的
                    declaredField.setAccessible(true);
                    // 那麼這個時候還要構建這個屬性的bean.
                    /*
                     * 獲取屬性的名字
                     * 真實狀況, spring這裏會判斷, 是根據名字, 仍是類型, 仍是構造函數來獲取類.
                     * 咱們這裏模擬, 因此簡單一些, 直接根據名字獲取.
                     */
                    String name = declaredField.getName();

                    /**
                     * 這樣, 在這裏咱們就拿到了 instanceB 的 bean
                     */
                    Object fileObject = getBean(name);

                    // 爲屬性設置類型
                    declaredField.set(instanceBean, fileObject);
                }
            }


            /**
             * 第四步: 初始化
             * 初始化就是設置類的init-method.這個能夠設置也能夠不設置. 咱們這裏就不設置了
             */


            /**
             * 第五步: 放入到一級緩存
             *
             * 在這裏二級緩存存的是動態代理, 那麼一級緩存確定也要存動態代理的實例.
             * 從二級緩存中取出實例, 放入到一級緩存中
             */
            if (earlySingletonObjects.containsKey(beanName)) {
                instanceBean = earlySingletonObjects.get(beanName);
            }
            singletonObjects.put(beanName, instanceBean);

            // 刪除二級緩存

            // 刪除三級緩存
 } return instanceBean;
    }

而後在從緩存取數據的getSingleton()上也加一把鎖

private static Object getSingleton(String beanName) {
        //先去一級緩存裏拿,
        Object bean = singletonObjects.get(beanName);
        // 一級緩存中沒有, 可是正在建立的bean標識中有, 說明是循環依賴
        if (bean == null && singletonsCurrectlyInCreation.contains(beanName)) {
            synchronized (singletonObjects) {
                bean = earlySingletonObjects.get(beanName);
                // 若是二級緩存中沒有, 就從三級緩存中拿
                if (bean == null) {
                    // 從三級緩存中取
                    ObjectFactory objectFactory = singletonFactories.get(beanName);
                    if (objectFactory != null) {
                        // 這裏是真正建立動態代理的地方.
                        bean = objectFactory.getObject();
                        // 而後將其放入到二級緩存中. 由於若是有屢次依賴, 就去二級緩存中判斷. 已經有了就不在再次建立了
                        earlySingletonObjects.put(beanName, bean);
                    }
                }
            }
        } return bean;
    }

加了兩把鎖.

這樣, 在分析一下

如上圖,線程B執行到getSingleton()的時候, 從一級緩存中取沒有, 到二級緩存的時候就加鎖了,他要等待直到線程A完成執行完才能進入. 這樣就避免出現不完整bean的狀況.

三. 源碼解決

在建立實例bean的時候, 加了一把鎖, 鎖是一級緩存.

 1 public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
 2         Assert.notNull(beanName, "Bean name must not be null");
 3         synchronized (this.singletonObjects) { 4             // 第一步: 從一級緩存中獲取單例對象
 5             Object singletonObject = this.singletonObjects.get(beanName);
 6             if (singletonObject == null) {
 7                 if (this.singletonsCurrentlyInDestruction) {
 8                     throw new BeanCreationNotAllowedException(beanName,
 9                             "Singleton bean creation not allowed while singletons of this factory are in destruction " +
10                             "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
11                 }
12                 if (logger.isDebugEnabled()) {
13                     logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
14                 }
15                 // 第二步: 將bean添加到singletonsCurrentlyInCreation中, 表示bean正在建立
16                 beforeSingletonCreation(beanName);
17                 boolean newSingleton = false;
18                 boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
19                 if (recordSuppressedExceptions) {
20                     this.suppressedExceptions = new LinkedHashSet<>();
21                 }
22                 try {
23                     // 第三步: 這裏調用getObject()鉤子方法, 就會回調匿名函數, 調用singletonFactory的createBean()
24                     singletonObject = singletonFactory.getObject();
25                     newSingleton = true;
26                 }
27                 catch (IllegalStateException ex) {
28                     // Has the singleton object implicitly appeared in the meantime ->
29                     // if yes, proceed with it since the exception indicates that state.
30                     singletonObject = this.singletonObjects.get(beanName);
31                     if (singletonObject == null) {
32                         throw ex;
33                     }
34                 }
35                 catch (BeanCreationException ex) {
36                     if (recordSuppressedExceptions) {
37                         for (Exception suppressedException : this.suppressedExceptions) {
38                             ex.addRelatedCause(suppressedException);
39                         }
40                     }
41                     throw ex;
42                 }
43                 finally {
44                     if (recordSuppressedExceptions) {
45                         this.suppressedExceptions = null;
46                     }
47                     afterSingletonCreation(beanName);
48                 }
49                 if (newSingleton) {
50                     addSingleton(beanName, singletonObject);
51                 }
52             }
53             return singletonObject;
54 } 55     }

再從緩存中取數據的時候, 也加了一把鎖, 和咱們的demo邏輯是同樣的. 鎖也是一級緩存.

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        // 從一級緩存中獲取bean實例對象
        Object singletonObject = this.singletonObjects.get(beanName);
        /**
         * 若是在第一級的緩存中沒有獲取到對象, 而且singletonsCurrentlyIncreation爲true,也就是這個類正在建立.
         * 標明當前是一個循環依賴.
         *
         * 這裏有處理循環依賴的問題.-- 咱們使用三級緩存解決循環依賴
         */
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) { /**
                 * 從二級緩存中拿bean, 二級緩存中的對象是一個早期對象
                 * 什麼是早期對象?就是bean剛剛調用了構造方法, 尚未給bean的屬性進行賦值, 和初始化, 這就是早期對象
                  */

                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    /**
                     * 從三級緩存拿bean, singletonFactories是用來解決循環依賴的關鍵所在.
                     * 在ios後期的過程當中, 當bean調用了構造方法的時候, 把早期對象包裝成一個ObjectFactory對象,暴露在三級緩存中
                      */
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        /**
                         * 在這裏經過暴露的ObjectFactory包裝對象. 經過調用他的getObject()方法來獲取對象
                         * 在這個環節中會調用getEarlyBeanReference()來進行後置處理
                         */
                        singletonObject = singletonFactory.getObject();
                        // 把早期對象放置在二級緩存中
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        // 刪除三級緩存
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        } return singletonObject;
    }