FragmentManager fragmentManager = getFragmentManager();
FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

每个transaction是一组同时执行的变化的集合。用add(), remove(), replace()方法，把所有需要的变化加进去，然后调用commit()方法，将这些变化应用。在commit()方法之前，你可以调用addToBackStack()，把这个transaction加入back stack中去，这个back stack是由activity管理的，当用户按返回键时，就会回到上一个fragment的状态。下面的代码非常典型，用一个新的fragment取代之前的fragment，并且将之前的状态存储在back stack中。

// Create new fragment and transaction
Fragment newFragment = new ExampleFragment();
FragmentTransaction transaction = getFragmentManager().beginTransaction();

// Replace whatever is in the fragment_container view with this fragment,
// and add the transaction to the back stack
transaction.replace(R.id.fragment_container, newFragment);
transaction.addToBackStack(null);

// Commit the transaction
transaction.commit();

下面我们对上述代码中出现的函数进行分析，以此来逐步学习Fragment的管理机制。

getSupportFragmentManager()：

public FragmentManager getSupportFragmentManager() {
    return mFragments;
}

beginTransaction()：
该函数在FragmentManagerIMpl中的源码如下：

public FragmentTransaction beginTransaction() {
	return new BackStackRecord(this);
}

final class BackStackRecord extends FragmentTransaction implements
        FragmentManager.BackStackEntry, Runnable {...}

public FragmentTransaction replace(int containerViewId, Fragment fragment) {
	return replace(containerViewId, fragment, null);
}

public FragmentTransaction replace(int containerViewId, Fragment fragment, String tag) {
	if (containerViewId == 0) {
		throw new IllegalArgumentException("Must use non-zero containerViewId");
	}

	doAddOp(containerViewId, fragment, tag, OP_REPLACE);
	return this;
}

private void doAddOp(int containerViewId, Fragment fragment, String tag, int opcmd) {
	fragment.mFragmentManager = mManager;

	if (tag != null) {
		if (fragment.mTag != null && !tag.equals(fragment.mTag)) {
			throw new IllegalStateException("Can't change tag of fragment "
					+ fragment + ": was " + fragment.mTag
					+ " now " + tag);
		}
		fragment.mTag = tag;
	}

	if (containerViewId != 0) {
		if (fragment.mFragmentId != 0 && fragment.mFragmentId != containerViewId) {
			throw new IllegalStateException("Can't change container ID of fragment "
					+ fragment + ": was " + fragment.mFragmentId
					+ " now " + containerViewId);
		}
		fragment.mContainerId = fragment.mFragmentId = containerViewId;
	}

	Op op = new Op();
	op.cmd = opcmd;
	op.fragment = fragment;
	addOp(op);
}

void addOp(Op op) {
	if (mHead == null) {
		mHead = mTail = op;
	} else {
		op.prev = mTail;
		mTail.next = op;
		mTail = op;
	}
	op.enterAnim = mEnterAnim;
	op.exitAnim = mExitAnim;
	op.popEnterAnim = mPopEnterAnim;
	op.popExitAnim = mPopExitAnim;
	mNumOp++;
}

transaction.addToBackStack(null)设置了mAddToBackStack为true，源码如下：

public FragmentTransaction addToBackStack(String name) {
	if (!mAllowAddToBackStack) {
		throw new IllegalStateException(
				"This FragmentTransaction is not allowed to be added to the back stack.");
	}
	mAddToBackStack = true;
	mName = name;
	return this;
}

public int commit() {
	return commitInternal(false);
}

int commitInternal(boolean allowStateLoss) {
	if (mCommitted) throw new IllegalStateException("commit already called");
	if (FragmentManagerImpl.DEBUG) {
		Log.v(TAG, "Commit: " + this);
		LogWriter logw = new LogWriter(TAG);
		PrintWriter pw = new PrintWriter(logw);
		dump("  ", null, pw, null);
	}
	mCommitted = true;
	if (mAddToBackStack) {
		mIndex = mManager.allocBackStackIndex(this);
	} else {
		mIndex = -1;
	}
	mManager.enqueueAction(this, allowStateLoss);
	return mIndex;
}

public int allocBackStackIndex(BackStackRecord bse) {
	synchronized (this) {
		if (mAvailBackStackIndices == null || mAvailBackStackIndices.size() <= 0) {
			if (mBackStackIndices == null) {
				mBackStackIndices = new ArrayList<BackStackRecord>();
			}
			int index = mBackStackIndices.size();
			if (DEBUG) Log.v(TAG, "Setting back stack index " + index + " to " + bse);
			mBackStackIndices.add(bse);
			return index;

		} else {
			int index = mAvailBackStackIndices.remove(mAvailBackStackIndices.size()-1);
			if (DEBUG) Log.v(TAG, "Adding back stack index " + index + " with " + bse);
			mBackStackIndices.set(index, bse);
			return index;
		}
	}
}

public void enqueueAction(Runnable action, boolean allowStateLoss) {
	if (!allowStateLoss) {
		checkStateLoss();
	}
	synchronized (this) {
		if (mDestroyed || mActivity == null) {
			throw new IllegalStateException("Activity has been destroyed");
		}
		if (mPendingActions == null) {
			mPendingActions = new ArrayList<Runnable>();
		}
		mPendingActions.add(action);
		if (mPendingActions.size() == 1) {
			mActivity.mHandler.removeCallbacks(mExecCommit);
			mActivity.mHandler.post(mExecCommit);
		}
	}
}

该函数首先进行状态监测，查看该Fagment所在的Activity的生命周期是否处于Saving Activity之前，因为Activity保存状态往往是由用户离开那个Activity所造成的，在此之后执行commit会丢失一些状态信息。针对这种情况，可以使用commitAllowingStateLoss().最后将BackStackRecord加入到执行队列中。当第一次往执行
队列中添加消息时，首先会从消息队列中所有callback属性为mExecCommit的消息删除，然后重新将mExecCommit添加到消息队列。mExecCommit的定义如下：

Runnable mExecCommit = new Runnable() {
	@Override
	public void run() {
		execPendingActions();
	}
};

public boolean execPendingActions() {
    if (mExecutingActions) {
        throw new IllegalStateException("Recursive entry to executePendingTransactions");
    }
    
    if (Looper.myLooper() != mActivity.mHandler.getLooper()) {
        throw new IllegalStateException("Must be called from main thread of process");
    }

    boolean didSomething = false;

    while (true) {
        int numActions;
        
        synchronized (this) {
            if (mPendingActions == null || mPendingActions.size() == 0) {
                break;
            }
            
            numActions = mPendingActions.size();
            if (mTmpActions == null || mTmpActions.length < numActions) {
                mTmpActions = new Runnable[numActions];
            }
            mPendingActions.toArray(mTmpActions);
            mPendingActions.clear();
            mActivity.mHandler.removeCallbacks(mExecCommit);
        }
        //一次性执行完数组中所有的Action
        mExecutingActions = true;
        for (int i=0; i<numActions; i++) {
            mTmpActions[i].run();
            mTmpActions[i] = null;
        }
        mExecutingActions = false;
        didSomething = true;
    }
    
    if (mHavePendingDeferredStart) {
        boolean loadersRunning = false;
        for (int i=0; i<mActive.size(); i++) {
            Fragment f = mActive.get(i);
            if (f != null && f.mLoaderManager != null) {
                loadersRunning |= f.mLoaderManager.hasRunningLoaders();
            }
        }
        if (!loadersRunning) {
            mHavePendingDeferredStart = false;
            startPendingDeferredFragments();
        }
    }
    return didSomething;
}

public void run() {
	if (FragmentManagerImpl.DEBUG) Log.v(TAG, "Run: " + this);

	if (mAddToBackStack) {
		if (mIndex < 0) {
			throw new IllegalStateException("addToBackStack() called after commit()");
		}
	}

	bumpBackStackNesting(1);

	Op op = mHead;
	//遍历op,根据cmd的类型对Fragment和FragmentManager进行相应的设置
	while (op != null) {
		switch (op.cmd) {
			case OP_ADD: {
				Fragment f = op.fragment;
				f.mNextAnim = op.enterAnim;
				//将Fragment添加到FragmentManager中，其源码显示是将Fragment添加到FragmentManager中的mActive数组中，并将Fragment添加到了数组mAdded中。
				mManager.addFragment(f, false);
			} break;
			case OP_REPLACE: {
				Fragment f = op.fragment;
				if (mManager.mAdded != null) {
					//遍历已经添加的Fragment，
					for (int i=0; i<mManager.mAdded.size(); i++) {
						Fragment old = mManager.mAdded.get(i);
						if (FragmentManagerImpl.DEBUG) Log.v(TAG,
								"OP_REPLACE: adding=" + f + " old=" + old);
						//如果发现两个mContainerId一样，则进行特殊处理
						if (f == null || old.mContainerId == f.mContainerId) {
							if (old == f) {
								//两个Fragment一样，则置空，保留old中的Fragment
								op.fragment = f = null;
							} else {
								// 将old fragment加入到 op.removed数组中，保留op中的Fragment
								if (op.removed == null) {
									op.removed = new ArrayList<Fragment>();
								}
								op.removed.add(old);
								old.mNextAnim = op.exitAnim;
								if (mAddToBackStack) {
									//设置old Fragment在BackStack中的Number
									old.mBackStackNesting += 1;
									if (FragmentManagerImpl.DEBUG) Log.v(TAG, "Bump nesting of "
											+ old + " to " + old.mBackStackNesting);
								}
								//对old Fragment设置相应的状态属性，如mAdded、mRemoving， 从FragmentManager中移除oldFrgment的相关属性
								mManager.removeFragment(old, mTransition, mTransitionStyle);
							}
						}
					}
				}
				//将Fragment添加到FragmentManager中
				if (f != null) {
					f.mNextAnim = op.enterAnim;
					mManager.addFragment(f, false);
				}
			} break;
			case OP_REMOVE: 
			......
		}

		op = op.next;
	}
	//设置Fragment的当前状态，然后根据当前状态来回调Fragment的生命周期中的相关函数。此函数控制了Fragment的生命周期和Fragment的绘制，想要彻底理解Fragment的生命周期的同学可以认真研究此函数。
	mManager.moveToState(mManager.mCurState, mTransition,
			mTransitionStyle, true);
	
	//将BackStackRecord加入到BackStack中，并回调onBackStackChanged
	if (mAddToBackStack) {
		mManager.addBackStackState(this);
	}
}

void addBackStackState(BackStackRecord state) {
	if (mBackStack == null) {
		mBackStack = new ArrayList<BackStackRecord>();
	}
	mBackStack.add(state);
	//回调onBackStackChanged
	reportBackStackChanged();
}

小结：

FragmentTransaction中的Op链用来保存add、remove、replace等action，在FragmentTransaction的run执行时，Op链会被变量以调整每个节点的内容。

FragmentManager使用一个BackStack来管理FragmentTransaction；使用mAdded数组来添加被add的Fragment，Fragment的创建、显示等行为都受FragmentManager的控制。
FragmentManager中的moveToState()是一个非常重要的函数，在FragmentTransaction run的时候被调用。下次我们将深入这个函数。