ViewPager.setOffscreenPageLimit

最新推荐文章于 2021-05-17 10:05:53 发布

Davisxy

最新推荐文章于 2021-05-17 10:05:53 发布

阅读量4.6k

点赞数 3

分类专栏： Android 文章标签： android

本文链接：https://blog.youkuaiyun.com/xiey94/article/details/108279343

版权

Android 专栏收录该内容

131 篇文章

订阅专栏

ViewPager.setOffscreenPageLimit

标签（空格分隔）： viewpager

测试demo:一个ViewPager+6个Fragment

setOffscreenPageLimit(1)

看到一些解释说setOffscreenPageLimit设置的数字有两层意思

一个是代表预加载的数量：n
一个是缓存的最大数量：2*n+1

此时依据上面描述，当设置为1时，预加载的数量是1，缓存的最大数量是3

下面来验证一下

初始化

Fragment1: onAttach
Fragment1: onCreate
Fragment2: onAttach
Fragment2: onCreate
Fragment1: onCreateView
Fragment1: onViewCreated
Fragment1: onActivityCreated
Fragment1: onStart
Fragment1: onResume
Fragment2: onCreateView
Fragment2: onViewCreated
Fragment2: onActivityCreated
Fragment2: onStart
Fragment2: onResume

一开始Fragment1执行到了onCreate，然后Fragment2执行到了onCreate；
得出第一个待验证结论：初始所有的能加载Fragment都将执行到onCreate

然后是第二波，同理结论：第二波都按照顺序执行到onResume

往前滑动到Fragment2

Fragment3: onAttach
Fragment3: onCreate
Fragment3: onCreateView
Fragment3: onViewCreated
Fragment3: onActivityCreated
Fragment3: onStart
Fragment3: onResume

Fragment3也是按照两拨，先到onCreate，然后到onResume；目前因为只有它一个初始化，所以看不明显；也得出一个待验证结论：预加载确实是1个

往前滑动到Fragment3

Fragment4: onAttach
Fragment4: onCreate
Fragment1: onPause
Fragment1: onStop
Fragment1: onDestroyView
Fragment1: onDestroy
Fragment1: onDetach
Fragment4: onCreateView
Fragment4: onViewCreated
Fragment4: onActivityCreated
Fragment4: onStart
Fragment4: onResume

第一波先是Fragment4这个预加载执行到onCreate，然后Fragment1开始执行销毁一直到onDetach，然后Fragment4执行了第二波一直到onResume；
得出第三个待验证结论：到目前为止缓存好像真的最大就是3个
得出第四个待验证结论：加载真的就一直是分两拨进行，第一波先是到onCreate，第二波是到onResume
得出第五个待验证结论：碰到有销毁的时候，销毁是卡在第一波和第二波之间，而且销毁是一次性直接从onPause执行到onDetach的

往前滑动到Fragment4

Fragment5: onAttach
Fragment5: onCreate
Fragment2: onPause
Fragment2: onStop
Fragment2: onDestroyView
Fragment2: onDestroy
Fragment2: onDetach
Fragment5: onCreateView
Fragment5: onViewCreated
Fragment5: onActivityCreated
Fragment5: onStart
Fragment5: onResume

同上面一波操作，销毁了Fragment2，预加载了Fragment5，结果打印数据更加证实了上面的三个待验证结论

往前滑动到Fragment5

Fragment6: onAttach
Fragment6: onCreate
Fragment3: onPause
Fragment3: onStop
Fragment3: onDestroyView
Fragment3: onDestroy
Fragment3: onDetach
Fragment6: onCreateView
Fragment6: onViewCreated
Fragment6: onActivityCreated
Fragment6: onStart
Fragment6: onResume

又同上，销毁了Fragment3，预加载了Fragment6

往前滑动到Fragment6

Fragment4: onPause
Fragment4: onStop
Fragment4: onDestroyView
Fragment4: onDestroy
Fragment4: onDetach

因为一共就是6个Fragment，所以滑动到了Fragment6的时候，就没有待预加载的Fragment了；滑动之前，界面在Fragment5的时候，缓存的Fragment有Fragment4、Fragment5、Fragment6，缓存了3个Fragment；滑动到Fragment6之前，数据一致都是符合之前的猜测的，最大缓存数据是3个，但是到了Fragment6的时候，因为没有下一个预加载页面，按照猜想应该没有任何生命周期方法执行，就保持3个缓存就好了，但是打印数据告诉我，Fragment4被销毁了，此时缓存中只有2个Fragment，也就是Fragment5、Fragment6；

往回滑动到Fragment5

Fragment4: onAttach
Fragment4: onCreate
Fragment4: onCreateView
Fragment4: onViewCreated
Fragment4: onActivityCreated
Fragment4: onStart
Fragment4: onResume

Fragment4被预加载了，此时缓存中就是三个Fragment：Fragment4、Fragment5、Fragment6

往回滑动到Fragment4

Fragment3: onAttach
Fragment3: onCreate
Fragment6: onPause
Fragment6: onStop
Fragment6: onDestroyView
Fragment6: onDestroy
Fragment6: onDetach
Fragment3: onCreateView
Fragment3: onViewCreated
Fragment3: onActivityCreated
Fragment3: onStart
Fragment3: onResume

回到了熟悉的流程，预加载了Fragment3，销毁了Fragment6

往回滑动到Fragment3

Fragment2: onAttach
Fragment2: onCreate
Fragment5: onPause
Fragment5: onStop
Fragment5: onDestroyView
Fragment5: onDestroy
Fragment5: onDetach
Fragment2: onCreateView
Fragment2: onViewCreated
Fragment2: onActivityCreated
Fragment2: onStart
Fragment2: onResume

同上，预加载了Fragment2，销毁了Fragment5

往回滑动到Fragment2

Fragment1: onAttach
Fragment1: onCreate
Fragment4: onPause
Fragment4: onStop
Fragment4: onDestroyView
Fragment4: onDestroy
Fragment4: onDetach
Fragment1: onCreateView
Fragment1: onViewCreated
Fragment1: onActivityCreated
Fragment1: onStart
Fragment1: onResume

同上，预加载了Fragment1，销毁了Fragment4

往回滑动到Fragment1

Fragment3: onPause
Fragment3: onStop
Fragment3: onDestroyView
Fragment3: onDestroy
Fragment3: onDetach

Fragment3被销毁了，此时缓存中只有Fragment1、Fragment2；
得出一个猜测：缓存的数量首先和预加载有关，其次与左右有关

往前滑动到Fragment2

Fragment3: onAttach
Fragment3: onCreate
Fragment3: onCreateView
Fragment3: onViewCreated
Fragment3: onActivityCreated
Fragment3: onStart
Fragment3: onResume

预加载了Fragment3

往前滑动到Fragment3

Fragment4: onAttach
Fragment4: onCreate
Fragment1: onPause
Fragment1: onStop
Fragment1: onDestroyView
Fragment1: onDestroy
Fragment1: onDetach
Fragment4: onCreateView
Fragment4: onViewCreated
Fragment4: onActivityCreated
Fragment4: onStart
Fragment4: onResume

再就不往下滑动记录了，这种情况下的规律基本上就是这些了。

总结一下

目前为止，根据记录的日志和分析，得到了6个待验证结论，和一个猜测
结论：

初始所有的能加载Fragment都将执行到onCreate
预加载确实是1个
到目前为止缓存好像真的最大就是3个
加载真的就一直是分两拨进行，第一波先是到onCreate，第二波是到onResume
碰到有销毁的时候，销毁是卡在第一波和第二波之间，而且销毁是一次性直接从onPause执行到onDetach的

猜测：

缓存的数量首先和预加载有关，其次与左右有关

到目前为止，结论1都是成立的；
到目前为止，结论2也是成立的；
到目前为止，结论3也是成立的；
到目前为止，结论4也是成立的；
到目前为止，结论5也是成立的；

猜测这个暂时先放放，我们把操作数据限制改改
setOffscreenPageLimit(2)

初始化

Fragment1: onAttach
Fragment1: onCreate
Fragment2: onAttach
Fragment2: onCreate
Fragment3: onAttach
Fragment3: onCreate
Fragment1: onCreateView
Fragment1: onViewCreated
Fragment1: onActivityCreated
Fragment1: onStart
Fragment1: onResume
Fragment2: onCreateView
Fragment2: onViewCreated
Fragment2: onActivityCreated
Fragment3: onCreateView
Fragment3: onViewCreated
Fragment3: onActivityCreated
Fragment2: onStart
Fragment2: onResume
Fragment3: onStart
Fragment3: onResume

好像有点不一样了，初始化好像变成了3波：
第一波到onCreate，第二波到onActivityCreated，第三波到onResume；
有一个例外就是第一个Fragment仍然是两拨如之前，剩下的预加载Fragment是3波；
为了准确行，我多试了几次：
唯一有变化不同的地方就是最后四条的顺序：

Fragment2: onStart
Fragment2: onResume
Fragment3: onStart
Fragment3: onResume

或

Fragment3: onStart
Fragment3: onResume
Fragment2: onStart
Fragment2: onResume

其他的不变；

为了数据的严谨，我尝试了

setOffscreenPageLimit(2)
setOffscreenPageLimit(3)
setOffscreenPageLimit(4)
setOffscreenPageLimit(5)
setOffscreenPageLimit(6)

结论依旧同上，看来是不会再有其他的变化了

第一个Fragment生命周期执行分两拨，onCreate结尾和onResume结尾；
剩下的预加载Fragment生命周期执行分三波，onCreate结尾、onActivityCreated结尾；都是按照顺序来的，最后的onStart-onResume是连着的，但是这最后一波的执行顺序不确定

再接着setOffscreenPageLimit(2)；

滑动到Fragment2

Fragment4: onAttach
Fragment4: onCreate
Fragment4: onCreateView
Fragment4: onViewCreated
Fragment4: onActivityCreated
Fragment4: onStart
Fragment4: onResume

Fragment4被预加载

滑动到Fragment3

Fragment5: onAttach
Fragment5: onCreate
Fragment5: onCreateView
Fragment5: onViewCreated
Fragment5: onActivityCreated
Fragment5: onStart
Fragment5: onResume

Fragment5被预加载

滑动到Fragment4

Fragment6: onAttach
Fragment6: onCreate
Fragment1: onPause
Fragment1: onStop
Fragment1: onDestroyView
Fragment1: onDestroy
Fragment1: onDetach
Fragment6: onCreateView
Fragment6: onViewCreated
Fragment6: onActivityCreated
Fragment6: onStart
Fragment6: onResume

Fragment1被销毁，Fragment6被预加载，可以看出最大缓存数确实是2*n+1，n=2，缓存为5

滑动到Fragment5

Fragment2: onPause
Fragment2: onStop
Fragment2: onDestroyView
Fragment2: onDestroy
Fragment2: onDetach

Fragment2被销毁

滑动到Fragment6

Fragment3: onPause
Fragment3: onStop
Fragment3: onDestroyView
Fragment3: onDestroy
Fragment3: onDetach

Fragment3被销毁

往回滑动到Fragment5

Fragment3: onAttach
Fragment3: onCreate
Fragment3: onCreateView
Fragment3: onViewCreated
Fragment3: onActivityCreated
Fragment3: onStart
Fragment3: onResume

Fragment3被预加载

往回滑动到Fragment4

Fragment2: onAttach
Fragment2: onCreate
Fragment2: onCreateView
Fragment2: onViewCreated
Fragment2: onActivityCreated
Fragment2: onStart
Fragment2: onResume

Fragment2被预加载

往回滑动到Fragment3

Fragment1: onAttach
Fragment1: onCreate
Fragment6: onPause
Fragment6: onStop
Fragment6: onDestroyView
Fragment6: onDestroy
Fragment6: onDetach
Fragment1: onCreateView
Fragment1: onViewCreated
Fragment1: onActivityCreated
Fragment1: onStart
Fragment1: onResume

预加载了Fragment1，销毁了Fragment6

往回滑动到Fragment2

Fragment5: onPause
Fragment5: onStop
Fragment5: onDestroyView
Fragment5: onDestroy
Fragment5: onDetach

销毁了Fragment5

往回滑动到Fragment1

Fragment4: onPause
Fragment4: onStop
Fragment4: onDestroyView
Fragment4: onDestroy
Fragment4: onDetach

Fragment4被销毁了

往前滑动到Fragment2

Fragment4: onAttach
Fragment4: onCreate
Fragment4: onCreateView
Fragment4: onViewCreated
Fragment4: onActivityCreated
Fragment4: onStart
Fragment4: onResume

Fragment4被预加载了

多余的数据就不打印了；
可以验证那个猜测：
缓存的最大数量仍然是2*n+1；但是他不是有增无减，他的缓存保持在自己占据一个，然后左边排列的占据n个，右边排列的占据n个，不偏不齐，左边有就有，没有就没有，右边同理；

所以可以得出结论：

初始所有的能加载Fragment都将执行到onCreate
预加载确实是1个
到目前为止缓存好像真的最大就是3个
第一个Fragment生命周期执行分两拨，onCreate结尾和onResume结尾；
剩下的预加载Fragment生命周期执行分三波，onCreate结尾、onActivityCreated结尾；都是按照顺序来的，最后的onStart-onResume是连着的，但是这最后一波的执行顺序不确定
碰到有销毁的时候，销毁是卡在第一波和第二波之间，而且销毁是一次性直接从onPause执行到onDetach的
缓存的数量首先和预加载有关，其次与左右有关；始终是自己占据一个缓存，自己左边按照排列缓存n个，自己右边按照排列缓存n个，当左右边小于等于n的时候，就以实际数据为准，就相当于：Math.min(2,实际数据)

以上都是基于AndroidX的behavior=BEHAVIOR_SET_USER_VISIBLE_HINT兼容旧版本的基础上测试的，测试代码：

view_pager = findViewById(R.id.view_pager);

        final List<Fragment> fragments = new ArrayList<>();
        fragments.add(new Fragment1());
        fragments.add(new Fragment2());
        fragments.add(new Fragment3());
        fragments.add(new Fragment4());
        fragments.add(new Fragment5());
        fragments.add(new Fragment6());


        view_pager.setAdapter(new FragmentStatePagerAdapter(getSupportFragmentManager()) {
            @NonNull
            @Override
            public Fragment getItem(int position) {
                return fragments.get(position);
            }

            @Override
            public int getCount() {
                return fragments.size();
            }
        });
        view_pager.setOffscreenPageLimit(2);

现在试一下behavior=BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT

view_pager = findViewById(R.id.view_pager);

        final List<Fragment> fragments = new ArrayList<>();
        fragments.add(new Fragment1());
        fragments.add(new Fragment2());
        fragments.add(new Fragment3());
        fragments.add(new Fragment4());
        fragments.add(new Fragment5());
        fragments.add(new Fragment6());


        view_pager.setAdapter(new FragmentStatePagerAdapter(getSupportFragmentManager(), FragmentStatePagerAdapter.BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT) {
            @NonNull
            @Override
            public Fragment getItem(int position) {
                return fragments.get(position);
            }

            @Override
            public int getCount() {
                return fragments.size();
            }
        });
        view_pager.setOffscreenPageLimit(1);

初始化

Fragment1: onAttach
Fragment1: onCreate
Fragment2: onAttach
Fragment2: onCreate
Fragment1: onCreateView
Fragment1: onViewCreated
Fragment1: onActivityCreated
Fragment1: onStart
Fragment2: onCreateView
Fragment2: onViewCreated
Fragment2: onActivityCreated
Fragment2: onStart
Fragment1: onResume

这次是分成了3波，第一波不变到onCreate收尾；第二波变了，到了onStart收尾，最后当前显示的页面调用了onResume

向前滑动到Fragment2

Fragment3: onAttach
Fragment3: onCreate
Fragment3: onCreateView
Fragment3: onViewCreated
Fragment3: onActivityCreated
Fragment3: onStart
Fragment1: onPause
Fragment2: onResume

预加载了Fragment3，调用了Fragment1的onPause，然后调用了Fragment2的onResume

向前滑动到Fragment3

Fragment4: onAttach
Fragment4: onCreate
Fragment1: onStop
Fragment1: onDestroyView
Fragment1: onDestroy
Fragment1: onDetach
Fragment4: onCreateView
Fragment4: onViewCreated
Fragment4: onActivityCreated
Fragment4: onStart
Fragment2: onPause
Fragment3: onResume

预加载了Fragment4，分两拨进行；销毁了Fragment1，调用了滑动之前界面Fragment2的onPause，最后调用了当前页面Fragment3的onResume；

向前滑动到Fragment4

Fragment5: onAttach
Fragment5: onCreate
Fragment2: onStop
Fragment2: onDestroyView
Fragment2: onDestroy
Fragment2: onDetach
Fragment5: onCreateView
Fragment5: onViewCreated
Fragment5: onActivityCreated
Fragment5: onStart
Fragment3: onPause
Fragment4: onResume

预加载Fragment5，分两拨进行，销毁Fragment2；然后调用滑动之前页面Fragment3的onPause，调用当前页面Fragment4的onResume；

向前滑动到Fragment5

Fragment6: onAttach
Fragment6: onCreate
Fragment3: onStop
Fragment3: onDestroyView
Fragment3: onDestroy
Fragment3: onDetach
Fragment6: onCreateView
Fragment6: onViewCreated
Fragment6: onActivityCreated
Fragment6: onStart
Fragment4: onPause
Fragment5: onResume

预加载Fragment6，销毁Fragment3页面；然后调用滑动之前页面Fragment4的onPause，调用当前页面Fragment5的onResume；

向前滑动到Fragment6

Fragment4: onStop
Fragment4: onDestroyView
Fragment4: onDestroy
Fragment4: onDetach
Fragment5: onPause
Fragment6: onResume

销毁Fragment4；然后调用滑动之前页面Fragment5的onPause，调用当前页面Fragment6的onResume；

往回滑动到Fragment5

Fragment4: onAttach
Fragment4: onCreate
Fragment4: onCreateView
Fragment4: onViewCreated
Fragment4: onActivityCreated
Fragment4: onStart
Fragment6: onPause
Fragment5: onResume

预加载Fragment4；然后调用滑动之前页面Fragment6的onPause，调用当前页面Fragment5的onResume；

通过以上数据相信已经看出来了，和之前版本的区别就是，onResume是直到当前页面显示了才执行，同时前一个页码会执行onPause；其他的基本不变，依据上面的这条规律，做懒加载可以更加的方便了。

那看看

setOffscreenPageLimit(2)
setOffscreenPageLimit(3)
setOffscreenPageLimit(4)
setOffscreenPageLimit(5)
setOffscreenPageLimit(6)

会有啥区别

setOffscreenPageLimit(2)

初始化

Fragment1: onAttach
Fragment1: onCreate
Fragment2: onAttach
Fragment2: onCreate
Fragment3: onAttach
Fragment3: onCreate
Fragment1: onCreateView
Fragment1: onViewCreated
Fragment1: onActivityCreated
Fragment1: onStart
Fragment2: onCreateView
Fragment2: onViewCreated
Fragment2: onActivityCreated
Fragment2: onStart
Fragment3: onCreateView
Fragment3: onViewCreated
Fragment3: onActivityCreated
Fragment3: onStart
Fragment1: onResume

预加载Fragment1、Fragment2、Fragment3；页面都是分两拨走，第一波到onCreate，第二波到onStart，最后调用显示页面也就是第一个页面Fragment1的onResume；

向前滑动到Fragment1

Fragment4: onAttach
Fragment4: onCreate
Fragment4: onCreateView
Fragment4: onViewCreated
Fragment4: onActivityCreated
Fragment4: onStart
Fragment1: onPause
Fragment2: onResume

和之前的又一样了

后面的

setOffscreenPageLimit(3)
setOffscreenPageLimit(4)
setOffscreenPageLimit(5)
setOffscreenPageLimit(6)

显示的数据规律不变；
但是除了多了一个onResume和onPause的替换执行，还多了一条不一样的东西，就是他的第一波和第二波始终是按照顺序来执行的；旧版本的除了第一个Fragment，后面的都是分三波，且最后一波不按照顺序执行；

总结一下：

.setAdapter(new FragmentStatePagerAdapter(getSupportFragmentManager())
或者
.setAdapter(new FragmentStatePagerAdapter(getSupportFragmentManager(), FragmentStatePagerAdapter.BEHAVIOR_SET_USER_VISIBLE_HINT) {

时，规律和结论：

初始所有的能加载Fragment都将执行到onCreate
预加载是n个
缓存最大就是2*n+1个
第一个Fragment生命周期执行分两拨，onCreate结尾和onResume结尾；
剩下的预加载Fragment生命周期执行分三波，onCreate结尾、onActivityCreated结尾；都是按照顺序来的，最后的onStart-onResume是连着的，但是这最后一波的执行顺序不确定
碰到有销毁的时候，销毁是卡在第一波和第二波之间，而且销毁是一次性直接从onPause执行到onDetach的
缓存的数量首先和预加载有关，其次与左右有关；始终是自己占据一个缓存，自己左边按照排列缓存n个，自己右边按照排列缓存n个，当左右边小于等于n的时候，就以实际数据为准，就相当于：Math.min(n,实际数据)

.setAdapter(new FragmentStatePagerAdapter(getSupportFragmentManager(), FragmentStatePagerAdapter.BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT)

时，规律和结论：

初始化所有能加载Fragment都将执行onAttach、onCreate
预加载是n个
缓存最大就是2*n+1
加载分两拨进行，且按照顺序进行；第一波都是执行到onCreate，第二波都是执行到onStart，最后当前显示的页面执行onResume；如果当前显示的页面是从某个同等页面划过来的，那之前的页面先执行onPause，当前页面再执行onResume
碰到有销毁的时候，销毁是卡在第一波和第二波之间，而且销毁是一次性直接从onPause执行到onDetach的
缓存的数量首先和预加载有关，其次与左右有关；始终是自己占据一个缓存，自己左边按照排列缓存n个，自己右边按照排列缓存n个，当左右边小于等于n的时候，就以实际数据为准，就相当于：Math.min(n,实际数据)

以上规律有很多相同之处和不同之处：

相同之处

初始化所有能加载Fragment都将执行onAttach、onCreate
预加载是n个
缓存最大就是2*n+1
碰到有销毁的时候，销毁是卡在第一波和第二波之间，而且销毁是一次性直接从onPause执行到onDetach的
缓存的数量首先和预加载有关，其次与左右有关；始终是自己占据一个缓存，自己左边按照排列缓存n个，自己右边按照排列缓存n个，当左右边小于等于n的时候，就以实际数据为准，就相当于：Math.min(n,实际数据)

不同之处

旧版

第一个Fragment生命周期执行分两拨，onCreate结尾和onResume结尾；
剩下的预加载Fragment生命周期执行分三波，onCreate结尾、onActivityCreated结尾；都是按照顺序来的，最后的onStart-onResume是连着的，但是这最后一波的执行顺序不确定

新版

加载分两拨进行，且按照顺序进行；第一波都是执行到onCreate，第二波都是执行到onStart，最后当前显示的页面执行onResume；如果当前显示的页面是从某个同等页面划过来的，那之前的页面先执行onPause，当前页面再执行onResume

还存在ViewPager+Fragment(嵌套ViewPager+Fragment)，这个后续探讨。

后续来了：

demo:一个ViewPager+6个Fragment，每个Fragment中又是：一个ViewPager+6个Fragment

这样看起来数据比较充实，但是又有点复杂；所以就不打印数据了，直接说出我观察到的结论：

setOffscreenPageLimit(2)，父和子都是这个设置

BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT 这种情况下

显示预加载Fragment1、Fragment2，仍然是两拨，最后当前也就是第一个Fragment1执行onResume；到这之前和没有子页面执行一致；
然后开始子页面的执行，先是预加载FragmentChild11、FragmentChild12，流程和上面的一样，也是最后FragmentChild11执行onResume；
然后是预加载FragmentChild21、FragmentChild22，流程和上面的一样，也是最后FragmentChild21执行onResume；

通过以上观察，可以看出基本和之前的规律是一样的，只不过是多了个子，而且子也是按照顺序执行的。

再然后就是子直接切换，跟之前的规律一样；
然后是某个父的子切完了，开始切父了，有了点变化：

Fragment3: onAttach
FragmentChild31: onAttach
FragmentChild31: onCreate
FragmentChild32: onAttach
FragmentChild32: onCreate
Fragment3: onCreate
Fragment3: onCreateView
Fragment3: onViewCreated
Fragment3: onActivityCreated
FragmentChild31: onCreateView
FragmentChild31: onViewCreated
FragmentChild31: onActivityCreated
FragmentChild32: onCreateView
FragmentChild32: onViewCreated
FragmentChild32: onActivityCreated
Fragment3: onStart
FragmentChild31: onStart
FragmentChild32: onStart
FragmentChild16: onPause
Fragment1: onPause
Fragment2: onResume
FragmentChild21: onResume

如上可看出：
先预加载Fragment3，这次是穿插着子（FragmentChild31/FragmentChild32）的生命周期，同样是分两拨，一直到onStart结束，最后四个方法：先调用之前显示页面的子的onPause，然后是之前显示页面父的onPause，然后调用当前显示父的onResume，然后显示当前子的onResume。

上面有三波数据：

父的预加载方法
最后的四个方法
两个子的预加载方法

前面两拨数据的顺序是固定的，最后那两个子的预加载数据是不固定的，可能会穿插；
目前我碰到的就是，冷启动APP后，当到达上面这个页面时，是穿插的；

Fragment3: onAttach
Fragment3: onCreate
Fragment3: onCreateView
Fragment3: onViewCreated
Fragment3: onActivityCreated
Fragment3: onStart
FragmentChild16: onPause
Fragment1: onPause
Fragment2: onResume
FragmentChild21: onResume
FragmentChild31: onAttach
FragmentChild31: onCreate
FragmentChild32: onAttach
FragmentChild32: onCreate
FragmentChild31: onCreateView
FragmentChild31: onViewCreated
FragmentChild31: onActivityCreated
FragmentChild31: onStart
FragmentChild32: onCreateView
FragmentChild32: onViewCreated
FragmentChild32: onActivityCreated
FragmentChild32: onStart

先是Fragment3预加载完成到onStart，然后就是那最后的四个方法，最后是子FragmentChild31/32预加载

之后不停切换到达这个页面时，又是按照上面打印顺序的