public final class ActivityThread {
//...　
final H mH = new H();
final ArrayMap<IBinder, ActivityClientRecord> mActivities = new ArrayMap<>();
final ArrayMap<IBinder, Service> mServices = new ArrayMap<>();final ApplicationThread mAppThread = new ApplicationThread(); 　private class ApplicationThread extends ApplicationThreadNative { 　　　//...
  }private class H extends Handler {//...
  }
//...
}  

public final class ActivityThread {//...private static ActivityThread sCurrentActivityThread;public static ActivityThread currentActivityThread() {return sCurrentActivityThread;}private void attach(boolean system) {sCurrentActivityThread = this;//...
    }
   public static void main(String[] args) {//....//创建Looper和MessageQueue对象，用于处理主线程的消息
        Looper.prepareMainLooper();//创建ActivityThread对象ActivityThread thread = new ActivityThread(); //建立Binder通道 (创建新线程)thread.attach(false);Looper.loop(); //消息循环运行throw new RuntimeException("Main thread loop unexpectedly exited");}}

   private void attach(boolean system) {sCurrentActivityThread = this;mSystemThread = system;if (!system) {//将mAppThread放到RuntimeInit类中的静态变量,也就是ApplicationThreadNative中的 this
            RuntimeInit.setApplicationObject(mAppThread.asBinder());final IActivityManager mgr = ActivityManagerNative.getDefault();try {mgr.attachApplication(mAppThread); //将mAppThread传入ActivityManagerService中} catch (RemoteException ex) {// Ignore
            }// Watch for getting close to heap limit.BinderInternal.addGcWatcher(new Runnable() {@Override public void run() {//...
                }});} else {// Don't set application object here -- if the system crashes,// we can't display an alert, we just want to die die die.android.ddm.DdmHandleAppName.setAppName("system_process",UserHandle.myUserId());try {mInstrumentation = new Instrumentation();ContextImpl context = ContextImpl.createAppContext(this, getSystemContext().mPackageInfo);mInitialApplication = context.mPackageInfo.makeApplication(true, null);mInitialApplication.onCreate();} catch (Exception e) {throw new RuntimeException("Unable to instantiate Application():" + e.toString(), e);}}//...}

final ApplicationThread mAppThread = new ApplicationThread();

例如:

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {//...调用performLaunchActivity方法完成Activity的启动Activity a = performLaunchActivity(r, customIntent);//...
}

public final class ActivityThread {
//...　
final H mH = new H();private class H extends Handler {//...声明的一些常量public void handleMessage(Message msg) {//...switch (msg.what) {//针对不同的常量，做不同的业务处理case LAUNCH_ACTIVITY: {//...启动一个ActivityhandleLaunchActivity(r, null, "LAUNCH_ACTIVITY");//...} break;case RELAUNCH_ACTIVITY: {//...
                    handleRelaunchActivity(r);//...} break;case PAUSE_ACTIVITY: {//...handlePauseActivity((IBinder) args.arg1, false,(args.argi1 & USER_LEAVING) != 0, args.argi2,(args.argi1 & DONT_REPORT) != 0, args.argi3);maybeSnapshot();//...} break;//...
            }//...
        }private void maybeSnapshot() {//...这个方法主要统计snapshot
        }}
} 

handleActivityConfigurationChanged()
handleBindApplication()
handleBindService()
handleCancelVisibleBehind()
handleConfigurationChanged()
handleCreateService()
handleDestroyActivity()
handleDispatchPackageBroadcast()
handleLaunchActivity()
handleLowMemory()
handleMessage()
handleNewIntent()
handlePauseActivity()
handleReceiver()
handleRelaunchActivity()
handleResumeActivity()
handleSendResult()
handleServiceArgs()
handleStopActivity()
handleStopService()

performDestroyActivity()
performDestroyActivity()
performLaunchActivity()
performNewIntents()
performPauseActivity()
performPauseActivity()
performRestartActivity()
performResumeActivity()
performStopActivity()
performStopActivityInner()
performUserLeavingActivity()

ActivityStack.startPausingLocked()
IApplicationThread.schedulePauseActivity()
ActivityThread.sendMessage()
ActivityThread.H.sendMessage();
ActivityThread.H.handleMessage()
ActivityThread.handlePauseActivity()
ActivityThread.performPauseActivity()
Activity.performPause()
Activity.onPause()
ActivityManagerNative.getDefault().activityPaused(token)
ActivityManagerService.activityPaused()
ActivityStack.activityPausedLocked()
ActivityStack.completePauseLocked()
ActivityStack.resumeTopActivitiesLocked()
ActivityStack.resumeTopActivityLocked()
ActivityStack.resumeTopActivityInnerLocked()
ActivityStack.startSpecificActivityLocked 

App进程则是我们常说的应用程序，主线程主要负责Activity/Service等组件的生命周期以及UI相关操作都运行在这个线程； 另外，每个App进程中至少会有两个binder线程 ApplicationThread和ActivityManagerProxy，除了图中画的线程，其中还有很多线程，比如signal catcher线程等，这里就不一一列举。

Binder用于不同进程之间通信，由一个进程的Binder客户端向另一个进程的服务端发送事务，比如图中线程2向线程4发送事务；而handler用于同一个进程中不同线程的通信，比如图中线程4向主线程发送消息。

例如:

需要暂停一个Activity

4.ApplicationThread

ActivityThread与启动Activity有关，那么ApplicationThread就与启动Application有关了

private class ApplicationThread extends ApplicationThreadNative {//...
    schedulePauseActivity()scheduleStopActivity()scheduleResumeActivity()scheduleSendResult()scheduleLaunchActivity()scheduleNewIntent()scheduleDestroyActivity()scheduleReceiver()scheduleCreateService()scheduleBindService()scheduleUnbindService()scheduleServiceArgs()scheduleStopService()bindApplication()scheduleConfigurationChanged()scheduleRegisteredReceiver()scheduleInstallProvider()
}

可以看出来它继承了ApplicationThreadNative的,并且它内部有非常多的scheduleXXX的方法.以后看到thread调用这个方法 就可以往这边找。我们先说一下这些方法，这些方法由外部的ActivityThread的binder远程代理对象调用最终走到这里.这些 schedulexxx的方法会进一步的通过往外发送消息给mH这个消息队列.来做处理

IApplicationThread

http://androidxref.com/6.0.0_r1/xref/frameworks/base/core/java/android/app/IApplicationThread.java

可以看到ApplicationThreadNative和ApplicationThreadProxy都实现了这个接口

public interface IApplicationThread extends IInterface {void schedulePauseActivity() throws RemoteException;void scheduleStopActivity() throws RemoteException;void scheduleWindowVisibility(IBinder token, boolean showWindow) throws RemoteException;void scheduleSleeping() throws RemoteException;void scheduleResumeActivity() throws RemoteException;void scheduleSendResult(IBinder token, List<ResultInfo> results) throws RemoteException;void scheduleLaunchActivity() throws RemoteException;void scheduleRelaunchActivity() throws RemoteException;void scheduleNewIntent() throws RemoteException;void scheduleReceiver() throws RemoteException;void scheduleCreateBackupAgent() throws RemoteException;void scheduleDestroyBackupAgent()throws RemoteException;void scheduleCreateService() throws RemoteException;void scheduleBindService() throws RemoteException;void scheduleUnbindService() throws RemoteException;void scheduleServiceArgs() throws RemoteException;void scheduleStopService() throws RemoteException;void bindApplication() throws RemoteException;void scheduleExit() throws RemoteException;void scheduleSuicide() throws RemoteException;void scheduleConfigurationChanged() throws RemoteException;//...
}

在来看看ApplicationThreadNative这个类

详细源码如下：
http://androidxref.com/6.0.0_r1/xref/frameworks/base/core/java/android/app/ApplicationThreadNative.java

public abstract class ApplicationThreadNative extends Binder implements IApplicationThread {//根据传入的不同参数决定返回不同的值.static public IApplicationThread asInterface(IBinder obj) {if (obj == null) {return null;}IApplicationThread in =(IApplicationThread)obj.queryLocalInterface(descriptor);if (in != null) {return in;}return new ApplicationThreadProxy(obj);}public ApplicationThreadNative() {attachInterface(this, descriptor);}@Overridepublic boolean onTransact(int code, Parcel data, Parcel reply, int flags)throws RemoteException {switch (code) {//...
        }}public IBinder asBinder(){return this;} }

说明：
      该类实现业务接口IApplicationThread,非常标准的Binder模板.IApplicationThread extends IInterface它里面就是定义了非常多的通信的业务接口，也都是schedulexxx理解上对应到ApplicationThread那些方法。
      该类首先是提供了一个静态的方法asInterface()用来获取IApplicationThread的Binder对象或者Binder代理对象,其它进程跨进程调用时候当传入的是BinderProxy那么就会返回一个ApplicationThreadProxy对象并把BinderProxy传入它的构造，而一般在本进程中调用的时候，就直接返回当前IApplicationThread对象，然后就是onTransact()函数了，里面通过不同的code对应到不同的case，进而调用不同的schedulexxx的方法，最终调用ApplicationThread中的schedulexxx方法。ApplicationThread这样就完成了作为服务端的构架,接下来就就是代理端的分析了.

前面我们知道跨进程调用asInterface的时候返回的是ApplicationThreadProxy对象,该类位于ApplicationThreadNative.java文件当中，是其内部类

ApplicationThreadProxy

public abstract class ApplicationThreadNative extends Binderimplements IApplicationThread {//...class ApplicationThreadProxy implements IApplicationThread {private final IBinder mRemote;public ApplicationThreadProxy(IBinder remote) {mRemote = remote;}public final IBinder asBinder() {return mRemote;}public final void schedulePauseActivity(IBinder token, boolean finished,boolean userLeaving, int configChanges, boolean dontReport) throws RemoteException {Parcel data = Parcel.obtain();data.writeInterfaceToken(IApplicationThread.descriptor);data.writeStrongBinder(token);data.writeInt(finished ? 1 : 0);data.writeInt(userLeaving ? 1 : 0);data.writeInt(configChanges);data.writeInt(dontReport ? 1 : 0);mRemote.transact(SCHEDULE_PAUSE_ACTIVITY_TRANSACTION, data, null,IBinder.FLAG_ONEWAY);data.recycle();}public final void scheduleStopActivity(IBinder token, boolean showWindow,int configChanges) throws RemoteException {//...
        }//...一些列的schedulexxx
}
}

说明，也是代理端的标准实现，实现了IApplicationThread 接口,然后实现接口中定义的业务方法，在每个方法中最终调用到了服务端的对应的schedulexxx方法中。当然这个过程是通过Binder通信调用的，例如上面通过mRemote变量和驱动去交互进而调用到server端, mRemote是一个BinderProxy对象.
       关于IApplicationThread的Binder相关实现，有个需要注意的它没有趣ServiceManager中注册，走的是一个匿名的binder的方法，其实对于驱动来说都一样.暂时发现的是别的地方如AMS用的时候通过ActivityThread的接口获得到ApplicationThread的对象,然后传入到asInterface(),获取对应的IApplicationThread对象进行跨进程调用。