看到幾篇關於RelativeLayout和LinearLayout效能分析的部落格，寫的相當不錯，這裡在大神的基礎上，增加了部分內容
     RelativeLayout和LinearLayout是Android中常用的佈局，兩者的使用會極大的影響程式生成每一幀的效能，因此，正確的使用它們是提升程式效能的重要工作。記得以前，較低的SDK版本新建Android專案時，預設的佈局檔案是採用線性佈局LinearLayout，但現在自動生成的佈局檔案都是RelativeLayout，或許你會認為這是IDE的預設設定問題，其實不然，這由 android-sdk\tools\templates\activities\BlankActivity\root\res\layout\activity_simple.xml.ftl 這個檔案事先就定好了的，也就是說這是Google的選擇，而非IDE的選擇。那SDK為什麼會預設給開發者新建一個預設的RelativeLayout佈局呢？<-----原因見最後小結
     當然是因為RelativeLayout的效能更優，效能至上嘛。但是我們再看看預設新建的這個RelativeLayout的父容器，也就是當前視窗的頂級View——DecorView，它卻是個垂直方向的LinearLayout，上面是標題欄，下面是內容欄。那麼問題來了，Google為什麼給開發者預設新建了個RelativeLayout，而自己卻偷偷用了個LinearLayout，到底誰的效能更高，開發者該怎麼選擇呢？
       下面將通過分析它們的原始碼來探討其View繪製效能，並得出其正確的使用方法。
 

一、View的一些基本工作原理

      先通過幾個問題，簡單的瞭解寫android中View的工作原理吧。
（1）View是什麼？
    簡單來說，View是Android系統在螢幕上的視覺呈現，也就是說你在手機螢幕上看到的東西都是View。
（2）View是怎麼繪製出來的？
    View的繪製流程是從ViewRoot的performTraversals（）方法開始，依次經過measure（），layout（）和draw（）三個過程才最終將一個View繪製出來。
（3）View是怎麼呈現在介面上的？
    Android中的檢視都是通過Window來呈現的，不管Activity、Dialog還是Toast它們都有一個Window，然後通過WindowManager來管理View。Window和頂級View——DecorView的通訊是依賴ViewRoot完成的。
（4）View和ViewGroup什麼區別？
 

    不管簡單的Button和TextView還是複雜的RelativeLayout和ListView，他們的共同基類都是View。所以說，View是一種介面層控制元件的抽象，他代表了一個控制元件。那ViewGroup是什麼東西，它可以被翻譯成控制元件組，即一組View。ViewGroup也是繼承View，這就意味著View本身可以是單個控制元件，也可以是多個控制元件組成的控制元件組。根據這個理論，Button顯然是個View，而RelativeLayout不但是一個View還可以是一個ViewGroup，而ViewGroup內部是可以有子View的，這個子View同樣也可能是ViewGroup，以此類推。

二、RelativeLayout和LinearLayout效能PK

       基於以上原理和大背景，我們要探討的效能問題，說的簡單明瞭一點就是：當RelativeLayout和LinearLayout分別作為ViewGroup，表達相同佈局時繪製在螢幕上時誰更快一點。上面已經簡單說了View的繪製，從ViewRoot的performTraversals（）方法開始依次呼叫perfromMeasure、performLayout和performDraw這三個方法。這三個方法分別完成頂級View的measure、layout和draw三大流程，其中perfromMeasure會呼叫measure，measure又會呼叫onMeasure，在onMeasure方法中則會對所有子元素進行measure，這個時候measure流程就從父容器傳遞到子元素中了，這樣就完成了一次measure過程，接著子元素會重複父容器的measure，如此反覆就完成了整個View樹的遍歷。同理，performLayout和performDraw也分別完成perfromMeasure類似的流程。通過這三大流程，分別遍歷整棵View樹，就實現了Measure，Layout，Draw這一過程，View就繪製出來了。那麼我們就分別來追蹤下RelativeLayout和LinearLayout這三大流程的執行耗時。
如下圖，我們分別用兩用種方式簡單的實現佈局測試下

LinearLayout
Measure：0.738ms
Layout：0.176ms
draw：7.655ms
RelativeLayout
Measure：2.280ms
Layout：0.153ms
draw：7.696ms
    從這個資料來看無論使用RelativeLayout還是LinearLayout，layout和draw的過程兩者相差無幾，考慮到誤差的問題，幾乎可以認為兩者不分伯仲，關鍵是Measure的過程RelativeLayout卻比LinearLayout慢了一大截。
（1）RelativeLayout的onMeasure()方法

1. protectedvoid onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
2.     if (mDirtyHierarchy) {  
3.         mDirtyHierarchy = false;  
4.         sortChildren();  
5.     }  
6.     int myWidth = -1;  
7.     int myHeight = -1;  
8.     int width = 0;  
9.     int height = 0;  
10.     finalint widthMode = MeasureSpec.getMode(widthMeasureSpec);  
11.     finalint heightMode = MeasureSpec.getMode(heightMeasureSpec);  
12.     finalint widthSize = MeasureSpec.getSize(widthMeasureSpec);  
13.     finalint heightSize = MeasureSpec.getSize(heightMeasureSpec);  
14.     // Record our dimensions if they are known;
15.     if (widthMode != MeasureSpec.UNSPECIFIED) {  
16.         myWidth = widthSize;  
17.     }  
18.     if (heightMode != MeasureSpec.UNSPECIFIED) {  
19.         myHeight = heightSize;  
20.     }  
21.     if (widthMode == MeasureSpec.EXACTLY) {  
22.         width = myWidth;  
23.     }  
24.     if (heightMode == MeasureSpec.EXACTLY) {  
25.         height = myHeight;  
26.     }  
27.     mHasBaselineAlignedChild = false;  
28.     View ignore = null;  
29.     int gravity = mGravity & Gravity.RELATIVE_HORIZONTAL_GRAVITY_MASK;  
30.     finalboolean horizontalGravity = gravity != Gravity.START && gravity != 0;  
31.     gravity = mGravity & Gravity.VERTICAL_GRAVITY_MASK;  
32.     finalboolean verticalGravity = gravity != Gravity.TOP && gravity != 0;  
33.     int left = Integer.MAX_VALUE;  
34.     int top = Integer.MAX_VALUE;  
35.     int right = Integer.MIN_VALUE;  
36.     int bottom = Integer.MIN_VALUE;  
37.     boolean offsetHorizontalAxis = false;  
38.     boolean offsetVerticalAxis = false;  
39.     if ((horizontalGravity || verticalGravity) && mIgnoreGravity != View.NO_ID) {  
40.         ignore = findViewById(mIgnoreGravity);  
41.     }  
42.     finalboolean isWrapContentWidth = widthMode != MeasureSpec.EXACTLY;  
43.     finalboolean isWrapContentHeight = heightMode != MeasureSpec.EXACTLY;  
44.     // We need to know our size for doing the correct computation of children positioning in RTL
45.     // mode but there is no practical way to get it instead of running the code below.
46.     // So, instead of running the code twice, we just set the width to a "default display width"
47.     // before the computation and then, as a last pass, we will update their real position with
48.     // an offset equals to "DEFAULT_WIDTH - width".
49.     finalint layoutDirection = getLayoutDirection();  
50.     if (isLayoutRtl() && myWidth == -1) {  
51.         myWidth = DEFAULT_WIDTH;  
52.     }  
53.     View[] views = mSortedHorizontalChildren;  
54.     int count = views.length;  
55.     for (int i = 0; i < count; i++) {  
56.         View child = views[i];  
57.         if (child.getVisibility() != GONE) {  
58.             LayoutParams params = (LayoutParams) child.getLayoutParams();  
59.             int[] rules = params.getRules(layoutDirection);  
60.             applyHorizontalSizeRules(params, myWidth, rules);  
61.             measureChildHorizontal(child, params, myWidth, myHeight);  
62.             if (positionChildHorizontal(child, params, myWidth, isWrapContentWidth)) {  
63.                 offsetHorizontalAxis = true;  
64.             }  
65.         }  
66.     }  
67.     views = mSortedVerticalChildren;  
68.     count = views.length;  
69.     finalint targetSdkVersion = getContext().getApplicationInfo().targetSdkVersion;  
70.     for (int i = 0; i < count; i++) {  
71.         View child = views[i];  
72.         if (child.getVisibility() != GONE) {  
73.             LayoutParams params = (LayoutParams) child.getLayoutParams();  
74.             applyVerticalSizeRules(params, myHeight);  
75.             measureChild(child, params, myWidth, myHeight);  
76.             if (positionChildVertical(child, params, myHeight, isWrapContentHeight)) {  
77.                 offsetVerticalAxis = true;  
78.             }  
79.             if (isWrapContentWidth) {  
80.                 if (isLayoutRtl()) {  
81.                     if (targetSdkVersion < Build.VERSION_CODES.KITKAT) {  
82.                         width = Math.max(width, myWidth - params.mLeft);  
83.                     } else {  
84.                         width = Math.max(width, myWidth - params.mLeft - params.leftMargin);  
85.                     }  
86.                 } else {  
87.                     if (targetSdkVersion < Build.VERSION_CODES.KITKAT) {  
88.                         width = Math.max(width, params.mRight);  
89.                     } else {  
90.                         width = Math.max(width, params.mRight + params.rightMargin);  
91.                     }  
92.                 }  
93.             }  
94.             if (isWrapContentHeight) {  
95.                 if (targetSdkVersion < Build.VERSION_CODES.KITKAT) {  
96.                     height = Math.max(height, params.mBottom);  
97.                 } else {  
98.                     height = Math.max(height, params.mBottom + params.bottomMargin);  
99.                 }  
100.             }  
101.             if (child != ignore || verticalGravity) {  
102.                 left = Math.min(left, params.mLeft - params.leftMargin);  
103.                 top = Math.min(top, params.mTop - params.topMargin);  
104.             }  
105.             if (child != ignore || horizontalGravity) {  
106.                 right = Math.max(right, params.mRight + params.rightMargin);  
107.                 bottom = Math.max(bottom, params.mBottom + params.bottomMargin);  
108.             }  
109.         }  
110.     }  
111.     if (mHasBaselineAlignedChild) {  
112.         for (int i = 0; i < count; i++) {  
113.             View child = getChildAt(i);  
114.             if (child.getVisibility() != GONE) {  
115.                 LayoutParams params = (LayoutParams) child.getLayoutParams();  
116.                 alignBaseline(child, params);  
117.                 if (child != ignore || verticalGravity) {  
118.                     left = Math.min(left, params.mLeft - params.leftMargin);  
119.                     top = Math.min(top, params.mTop - params.topMargin);  
120.                 }  
121.                 if (child != ignore || horizontalGravity) {  
122.                     right = Math.max(right, params.mRight + params.rightMargin);  
123.                     bottom = Math.max(bottom, params.mBottom + params.bottomMargin);  
124.                 }  
125.             }  
126.         }  
127.     }  
128.     if (isWrapContentWidth) {  
129.         // Width already has left padding in it since it was calculated by looking at
130.         // the right of each child view
131.         width += mPaddingRight;  
132.         if (mLayoutParams != null && mLayoutParams.width >= 0) {  
133.             width = Math.max(width, mLayoutParams.width);  
134.         }  
135.         width = Math.max(width, getSuggestedMinimumWidth());  
136.         width = resolveSize(width, widthMeasureSpec);  
137.         if (offsetHorizontalAxis) {  
138.             for (int i = 0; i < count; i++) {  
139.                 View child = getChildAt(i);  
140.                 if (child.getVisibility() != GONE) {  
141.                     LayoutParams params = (LayoutParams) child.getLayoutParams();  
142.                     finalint[] rules = params.getRules(layoutDirection);  
143.                     if (rules[CENTER_IN_PARENT] != 0 || rules[CENTER_HORIZONTAL] != 0) {  
144.                         centerHorizontal(child, params, width);  
145.                     } elseif (rules[ALIGN_PARENT_RIGHT] != 0) {  
146.                         finalint childWidth = child.getMeasuredWidth();  
147.                         params.mLeft = width - mPaddingRight - childWidth;  
148.                         params.mRight = params.mLeft + childWidth;  
149.                     }  
150.                 }  
151.             }  
152.         }  
153.     }  
154.     if (isWrapContentHeight) {  
155.         // Height already has top padding in it since it was calculated by looking at
156.         // the bottom of each child view
157.         height += mPaddingBottom;  
158.         if (mLayoutParams != null && mLayoutParams.height >= 0) {  
159.             height = Math.max(height, mLayoutParams.height);  
160.         }  
161.         height = Math.max(height, getSuggestedMinimumHeight());  
162.         height = resolveSize(height, heightMeasureSpec);  
163.         if (offsetVerticalAxis) {  
164.             for (int i = 0; i < count; i++) {  
165.                 View child = getChildAt(i);  
166.                 if (child.getVisibility() != GONE) {  
167.                     LayoutParams params = (LayoutParams) child.getLayoutParams();  
168.                     finalint[] rules = params.getRules(layoutDirection);  
169.                     if (rules[CENTER_IN_PARENT] != 0 || rules[CENTER_VERTICAL] != 0) {  
170.                         centerVertical(child, params, height);  
171.                     } elseif (rules[ALIGN_PARENT_BOTTOM] != 0) {  
172.                         finalint childHeight = child.getMeasuredHeight();  
173.                         params.mTop = height - mPaddingBottom - childHeight;  
174.                         params.mBottom = params.mTop + childHeight;  
175.                     }  
176.                 }  
177.             }  
178.         }  
179.     }  
180.     if (horizontalGravity || verticalGravity) {  
181.         final Rect selfBounds = mSelfBounds;  
182.         selfBounds.set(mPaddingLeft, mPaddingTop, width - mPaddingRight,  
183.                 height - mPaddingBottom);  
184.         final Rect contentBounds = mContentBounds;  
185.         Gravity.apply(mGravity, right - left, bottom - top, selfBounds, contentBounds,  
186.                 layoutDirection);  
187.         finalint horizontalOffset = contentBounds.left - left;  
188.         finalint verticalOffset = contentBounds.top - top;  
189.         if (horizontalOffset != 0 || verticalOffset != 0) {  
190.             for (int i = 0; i < count; i++) {  
191.                 View child = getChildAt(i);  
192.                 if (child.getVisibility() != GONE && child != ignore) {  
193.                     LayoutParams params = (LayoutParams) child.getLayoutParams();  
194.                     if (horizontalGravity) {  
195.                         params.mLeft += horizontalOffset;  
196.                         params.mRight += horizontalOffset;  
197.                     }  
198.                     if (verticalGravity) {  
199.                         params.mTop += verticalOffset;  
200.                         params.mBottom += verticalOffset;  
201.                     }  
202.                 }  
203.             }  
204.         }  
205.     }  
206.     if (isLayoutRtl()) {  
207.         finalint offsetWidth = myWidth - width;  
208.         for (int i = 0; i < count; i++) {  
209.             View child = getChildAt(i);  
210.             if (child.getVisibility() != GONE) {  
211.                 LayoutParams params = (LayoutParams) child.getLayoutParams();  
212.                 params.mLeft -= offsetWidth;  
213.                 params.mRight -= offsetWidth;  
214.             }  
215.         }  
216.     }  
217.     setMeasuredDimension(width, height);  
218. }  

     根據上述關鍵程式碼，RelativeLayout分別對所有子View進行兩次measure，橫向縱向分別進行一次，這是為什麼呢？首先RelativeLayout中子View的排列方式是基於彼此的依賴關係，而這個依賴關係可能和佈局中View的順序並不相同，在確定每個子View的位置的時候，需要先給所有的子View排序一下。又因為RelativeLayout允許A，B 2個子View，橫向上B依賴A，縱向上A依賴B。所以需要橫向縱向分別進行一次排序測量。 mSortedHorizontalChildren和mSortedVerticalChildren是分別對水平方向的子控制元件和垂直方向的子控制元件進行排序後的View陣列。

（2）LinearLayout的onMeasure()方法

1. @Override
2. protectedvoid onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
3.     if (mOrientation == VERTICAL) {  
4.         measureVertical(widthMeasureSpec, heightMeasureSpec);  
5.     } else {  
6.         measureHorizontal(widthMeasureSpec, heightMeasureSpec);  
7.     }  
8. }  

      與RelativeLayout相比LinearLayout的measure就簡單的多，只需判斷線性佈局是水平佈局還是垂直佈局即可，然後才進行測量：

1. /** 
2.  * Measures the children when the orientation of this LinearLayout is set 
3.  * to {@link #VERTICAL}. 
4.  * 
5.  * @param widthMeasureSpec Horizontal space requirements as imposed by the parent. 
6.  * @param heightMeasureSpec Vertical space requirements as imposed by the parent. 
7.  * 
8.  * @see #getOrientation() 
9.  * @see #setOrientation(int) 
10.  * @see #onMeasure(int, int) 
11.  */
12. void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {  
13.     mTotalLength = 0;  
14.     int maxWidth = 0;  
15.     int childState = 0;  
16.     int alternativeMaxWidth = 0;  
17.     int weightedMaxWidth = 0;  
18.     boolean allFillParent = true;  
19.     float totalWeight = 0;  
20.     finalint count = getVirtualChildCount();  
21.     finalint widthMode = MeasureSpec.getMode(widthMeasureSpec);  
22.     finalint heightMode = MeasureSpec.getMode(heightMeasureSpec);  
23.     boolean matchWidth = false;  
24.     boolean skippedMeasure = false;  
25.     finalint baselineChildIndex = mBaselineAlignedChildIndex;          
26.     finalboolean useLargestChild = mUseLargestChild;  
27.     int largestChildHeight = Integer.MIN_VALUE;  
28.     // See how tall everyone is. Also remember max width.
29.     for (int i = 0; i < count; ++i) {  
30.         final View child = getVirtualChildAt(i);  
31.         if (child == null) {  
32.             mTotalLength += measureNullChild(i);  
33.             continue;  
34.         }  
35.         if (child.getVisibility() == View.GONE) {  
36.            i += getChildrenSkipCount(child, i);  
37.            continue;  
38.         }  
39.         if (hasDividerBeforeChildAt(i)) {  
40.             mTotalLength += mDividerHeight;  
41.         }  
42.         LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();  
43.         totalWeight += lp.weight;  
44.         if (heightMode == MeasureSpec.EXACTLY && lp.height == 0 && lp.weight > 0) {  
45.             // Optimization: don't bother measuring children who are going to use
46.             // leftover space. These views will get measured again down below if
47.             // there is any leftover space.
48.             finalint totalLength = mTotalLength;  
49.             mTotalLength = Math.max(totalLength, totalLength + lp.topMargin + lp.bottomMargin);  
50.             skippedMeasure = true;  
51.         } else {  
52.             int oldHeight = Integer.MIN_VALUE;  
53.             if (lp.height == 0 && lp.weight > 0) {  
54.                 // heightMode is either UNSPECIFIED or AT_MOST, and this
55.                 // child wanted to stretch to fill available space.
56.                 // Translate that to WRAP_CONTENT so that it does not end up
57.                 // with a height of 0
58.                 oldHeight = 0;  
59.                 lp.height = LayoutParams.WRAP_CONTENT;  
60.             }  
61.             // Determine how big this child would like to be. If this or
62.             // previous children have given a weight, then we allow it to
63.             // use all available space (and we will shrink things later
64.             // if needed).
65.             measureChildBeforeLayout(  
66.                    child, i, widthMeasureSpec, 0, heightMeasureSpec,  
67.                    totalWeight == 0 ? mTotalLength : 0);  
68.             if (oldHeight != Integer.MIN_VALUE) {  
69.                lp.height = oldHeight;  
70.             }  
71.             finalint childHeight = child.getMeasuredHeight();  
72.             finalint totalLength = mTotalLength;  
73.             mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +  
74.                    lp.bottomMargin + getNextLocationOffset(child));  
75.             if (useLargestChild) {  
76.                 largestChildHeight = Math.max(childHeight, largestChildHeight);  
77.             }  
78.         }  
79.         /** 
80.          * If applicable, compute the additional offset to the child's baseline 
81.          * we'll need later when asked {@link #getBaseline}. 
82.          */
83.         if ((baselineChildIndex >= 0) && (baselineChildIndex == i + 1)) {  
84.            mBaselineChildTop = mTotalLength;  
85.         }  
86.         // if we are trying to use a child index for our baseline, the above
87.         // book keeping only works if there are no children above it with
88.         // weight.  fail fast to aid the developer.
89.         if (i < baselineChildIndex && lp.weight > 0) {  
90.             thrownew RuntimeException("A child of LinearLayout with index "
91.                     + "less than mBaselineAlignedChildIndex has weight > 0, which "
92.                     + "won't work.  Either remove the weight, or don't set "
93.                     + "mBaselineAlignedChildIndex.");  
94.         }  
95.         boolean matchWidthLocally = false;  
96.         if (widthMode != MeasureSpec.EXACTLY && lp.width == LayoutParams.MATCH_PARENT) {  
97.             // The width of the linear layout will scale, and at least one
98.             // child said it wanted to match our width. Set a flag
99.             // indicating that we need to remeasure at least that view when
100.             // we know our width.
101.             matchWidth = true;  
102.             matchWidthLocally = true;  
103.         }  
104.         finalint margin = lp.leftMargin + lp.rightMargin;  
105.         finalint measuredWidth = child.getMeasuredWidth() + margin;  
106.         maxWidth = Math.max(maxWidth, measuredWidth);  
107.         childState = combineMeasuredStates(childState, child.getMeasuredState());  
108.         allFillParent = allFillParent && lp.width == LayoutParams.MATCH_PARENT;  
109.         if (lp.weight > 0) {  
110.             /* 
111.              * Widths of weighted Views are bogus if we end up 
112.              * remeasuring, so keep them separate. 
113.              */
114.             weightedMaxWidth = Math.max(weightedMaxWidth,  
115.                     matchWidthLocally ? margin : measuredWidth);  
116.         } else {  
117.             alternativeMaxWidth = Math.max(alternativeMaxWidth,  
118.                     matchWidthLocally ? margin : measuredWidth);  
119.         }  
120.         i += getChildrenSkipCount(child, i);  
121.     }  
122.     if (mTotalLength > 0 && hasDividerBeforeChildAt(count)) {  
123.         mTotalLength += mDividerHeight;  
124.     }  
125.     if (useLargestChild &&  
126.             (heightMode == MeasureSpec.AT_MOST || heightMode == MeasureSpec.UNSPECIFIED)) {  
127.         mTotalLength = 0;  
128.         for (int i = 0; i < count; ++i) {  
129.             final View child = getVirtualChildAt(i);  
130.             if (child == null) {  
131.                 mTotalLength += measureNullChild(i);  
132.                 continue;  
133.             }  
134.             if (child.getVisibility() == GONE) {  
135.                 i += getChildrenSkipCount(child, i);  
136.                 continue;  
137.             }  
138.             final LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams)  
139.                     child.getLayoutParams();  
140.             // Account for negative margins
141.             finalint totalLength = mTotalLength;  
142.             mTotalLength = Math.max(totalLength, totalLength + largestChildHeight +  
143.                     lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));  
144.         }  
145.     }  
146.     // Add in our padding
147.     mTotalLength += mPaddingTop + mPaddingBottom;  
148.     int heightSize = mTotalLength;  
149.     // Check against our minimum height
150.     heightSize = Math.max(heightSize, getSuggestedMinimumHeight());  
151.     // Reconcile our calculated size with the heightMeasureSpec
152.     int heightSizeAndState = resolveSizeAndState(heightSize, heightMeasureSpec, 0);  
153.     heightSize = heightSizeAndState & MEASURED_SIZE_MASK;  
154.     // Either expand children with weight to take up available space or
155.     // shrink them if they extend beyond our current bounds. If we skipped
156.     // measurement on any children, we need to measure them now.
157.     int delta = heightSize - mTotalLength;  
158.     if (skippedMeasure || delta != 0 && totalWeight > 0.0f) {  
159.         float weightSum = mWeightSum > 0.0f ? mWeightSum : totalWeight;  
160.         mTotalLength = 0;  
161.         for (int i = 0; i < count; ++i) {  
162.             final View child = getVirtualChildAt(i);  
163.             if (child.getVisibility() == View.GONE) {  
164.                 continue;  
165.             }  
166.             LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();  
167.             float childExtra = lp.weight;  
168.             if (childExtra > 0) {  
169.                 // Child said it could absorb extra space -- give him his share
170.                 int share = (int) (childExtra * delta / weightSum);  
171.                 weightSum -= childExtra;  
172.                 delta -= share;  
173.                 finalint childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,  
174.                         mPaddingLeft + mPaddingRight +  
175.                                 lp.leftMargin + lp.rightMargin, lp.width);  
176.                 // TODO: Use a field like lp.isMeasured to figure out if this
177.                 // child has been previously measured
178.                 if ((lp.height != 0) || (heightMode != MeasureSpec.EXACTLY)) {  
179.                     // child was measured once already above...
180.                     // base new measurement on stored values
181.                     int childHeight = child.getMeasuredHeight() + share;  
182.                     if (childHeight < 0) {  
183.                         childHeight = 0;  
184.                     }  
185.                     child.measure(childWidthMeasureSpec,  
186.                             MeasureSpec.makeMeasureSpec(childHeight, MeasureSpec.EXACTLY));  
187.                 } else {  
188.                     // child was skipped in the loop above.
189.                     // Measure for this first time here      
190.                     child.measure(childWidthMeasureSpec,  
191.                             MeasureSpec.makeMeasureSpec(share > 0 ? share : 0,  
192.                                     MeasureSpec.EXACTLY));  
193.                 }  
194.                 // Child may now not fit in vertical dimension.
195.                 childState = combineMeasuredStates(childState, child.getMeasuredState()  
196.                         & (MEASURED_STATE_MASK>>MEASURED_HEIGHT_STATE_SHIFT));  
197.             }  
198.             finalint margin =  lp.leftMargin + lp.rightMargin;  
199.             finalint measuredWidth = child.getMeasuredWidth() + margin;  
200.             maxWidth = Math.max(maxWidth, measuredWidth);  
201.             boolean matchWidthLocally = widthMode != MeasureSpec.EXACTLY &&  
202.                     lp.width == LayoutParams.MATCH_PARENT;  
203.             alternativeMaxWidth = Math.max(alternativeMaxWidth,  
204.                     matchWidthLocally ? margin : measuredWidth);  
205.             allFillParent = allFillParent && lp.width == LayoutParams.MATCH_PARENT;  
206.             finalint totalLength = mTotalLength;  
207.             mTotalLength = Math.max(totalLength, totalLength + child.getMeasuredHeight() +  
208.                     lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));  
209.         }  
210.         // Add in our padding
211.         mTotalLength += mPaddingTop + mPaddingBottom;  
212.         // TODO: Should we recompute the heightSpec based on the new total length?
213.     } else {  
214.         alternativeMaxWidth = Math.max(alternativeMaxWidth,  
215.                                        weightedMaxWidth);  
216.         // We have no limit, so make all weighted views as tall as the largest child.
217.         // Children will have already been measured once.
218.         if (useLargestChild && heightMode != MeasureSpec.EXACTLY) {  
219.             for (int i = 0; i < count; i++) {  
220.                 final View child = getVirtualChildAt(i);  
221.                 if (child == null || child.getVisibility() == View.GONE) {  
222.                     continue;  
223.                 }  
224.                 final LinearLayout.LayoutParams lp =  
225.                         (LinearLayout.LayoutParams) child.getLayoutParams();  
226.                 float childExtra = lp.weight;  
227.                 if (childExtra > 0) {  
228.                     child.measure(  
229.                             MeasureSpec.makeMeasureSpec(child.getMeasuredWidth(),  
230.                                     MeasureSpec.EXACTLY),  
231.                             MeasureSpec.makeMeasureSpec(largestChildHeight,  
232.                                     MeasureSpec.EXACTLY));  
233.                 }  
234.             }  
235.         }  
236.     }  
237.     if (!allFillParent && widthMode != MeasureSpec.EXACTLY) {  
238.         maxWidth = alternativeMaxWidth;  
239.     }  
240.     maxWidth += mPaddingLeft + mPaddingRight;  
241.     // Check against our minimum width
242.     maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());  
243.     setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),  
244.             heightSizeAndState);  
245.     if (matchWidth) {  
246.         forceUniformWidth(count, heightMeasureSpec);  
247.     }  
248. }  

      LinearLayout首先會對所有的子View進行measure，並計算totalWeight(所有子View的weight屬性之和)，然後判斷子View的weight屬性是否為最大，如為最大則將剩餘的空間分配給它。如果不使用weight屬性進行佈局，則不進行第二次measure。

      父檢視在對子檢視進行measure操作的過程中，使用變數mTotalLength儲存已經measure過的child所佔用