ActivityThread一些浅薄理解

最新推荐文章于 2024-09-04 12:55:16 发布
最新推荐文章于 2024-09-04 12:55:16 发布
阅读量814 收藏 1
点赞数
分类专栏： 源码分析 文章标签： Android ActivityThread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/love943177923/article/details/88219340
版权

ActivityThread的main方法解读 

public static void main(String[] args) {
    ...
    ...
    //创建Looper
    Looper.prepareMainLooper();
    //创建ActivityThread示例并绑定
    ActivityThread thread = new ActivityThread();
    thread.attach(false);

    //获取Handler示例，ActivityThread内部创建了一个内部类H继承Handler，里面包含了一系列调用Activity生命周期的方法
    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }
   
    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
    //启动Loop循环，获取Handler从支发送的消息转发到主线程
    Looper.loop();

    throw new RuntimeException("Main thread loop unexpectedly exited");
} 

attach方法 

private void attach(boolean system) {  //system传递过来的是false，不是系统调用的
    sCurrentActivityThread = this;
    mSystemThread = system;
    if (!system) {
        ViewRootImpl.addFirstDrawHandler(new Runnable() {
            @Override
            public void run() {
                ensureJitEnabled();
            }
        });
        android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
                                                UserHandle.myUserId());
        RuntimeInit.setApplicationObject(mAppThread.asBinder());
        //获取远程AMS的代理对象,Android系统中存在一个ActivityManagerService,用来调度程序里面的Activity的开启等工作
        final IActivityManager mgr = ActivityManager.getService();
        try {
            //调用AMS的attachApplication方法，将mAppThread传递，AMS通过mAppThread和应用程序进行通信，下面我们来分析下
            //AMS拿到这个mAppThread之后都能干些什么
            mgr.attachApplication(mAppThread);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
        // Watch for getting close to heap limit.
        BinderInternal.addGcWatcher(new Runnable() {
            @Override public void run() {
                if (!mSomeActivitiesChanged) {
                    return;
                }
                Runtime runtime = Runtime.getRuntime();
                long dalvikMax = runtime.maxMemory();
                long dalvikUsed = runtime.totalMemory() - runtime.freeMemory();
                if (dalvikUsed > ((3*dalvikMax)/4)) {
                    if (DEBUG_MEMORY_TRIM) Slog.d(TAG, "Dalvik max=" + (dalvikMax/1024)
                            + " total=" + (runtime.totalMemory()/1024)
                            + " used=" + (dalvikUsed/1024));
                    mSomeActivitiesChanged = false;
                    try {
                        mgr.releaseSomeActivities(mAppThread);
                    } catch (RemoteException e) {
                        throw e.rethrowFromSystemServer();
                    }
                }
            }
        });
    } 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);
        }
    }

    ...
    ...
}

mAppThread在初始化的时候已经创建，下面是ApplicationThread源码

 

private class ApplicationThread extends IApplicationThread.Stub {
    private static final String DB_INFO_FORMAT = "  %8s %8s %14s %14s  %s";

    private int mLastProcessState = -1;

    private void updatePendingConfiguration(Configuration config) {
        synchronized (mResourcesManager) {
            if (mPendingConfiguration == null ||
                    mPendingConfiguration.isOtherSeqNewer(config)) {
                mPendingConfiguration = config;
            }
        }
    }
    
    //执行Activity的onPause生命周期方法
    public final void schedulePauseActivity(IBinder token, boolean finished,
            boolean userLeaving, int configChanges, boolean dontReport) {
        int seq = getLifecycleSeq();
        if (DEBUG_ORDER) Slog.d(TAG, "pauseActivity " + ActivityThread.this
                + " operation received seq: " + seq);
        sendMessage(
                finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
                token,
                (userLeaving ? USER_LEAVING : 0) | (dontReport ? DONT_REPORT : 0),
                configChanges,
                seq);
    }
    //执行Activity的onStop生命周期方法
    public final void scheduleStopActivity(IBinder token, boolean showWindow,
            int configChanges) {
        int seq = getLifecycleSeq();
        if (DEBUG_ORDER) Slog.d(TAG, "stopActivity " + ActivityThread.this
                + " operation received seq: " + seq);
        sendMessage(
            showWindow ? H.STOP_ACTIVITY_SHOW : H.STOP_ACTIVITY_HIDE,
            token, 0, configChanges, seq);
    }

    public final void scheduleWindowVisibility(IBinder token, boolean showWindow) {
        sendMessage(
            showWindow ? H.SHOW_WINDOW : H.HIDE_WINDOW,
            token);
    }

      ...

      省略部分代码

}

主要是调用Acitivity的生命周期方法，在方法里最后调用sendMessage方法，最后执行H类的handleMessage方法

 

内部类H继承Handler，包含了一系列启动Activity生命周期的方法

public void handleMessage(Message msg) {
        if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
        switch (msg.what) {
            case LAUNCH_ACTIVITY: {
                //启动Activity
                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
                final ActivityClientRecord r = (ActivityClientRecord) msg.obj;

                r.packageInfo = getPackageInfoNoCheck(
                        r.activityInfo.applicationInfo, r.compatInfo);
                handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            } break;
            case RELAUNCH_ACTIVITY: {
                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityRestart");
                ActivityClientRecord r = (ActivityClientRecord)msg.obj;
                handleRelaunchActivity(r);
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            } break;
            case PAUSE_ACTIVITY: {
                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
                SomeArgs args = (SomeArgs) msg.obj;
                handlePauseActivity((IBinder) args.arg1, false,
                        (args.argi1 & USER_LEAVING) != 0, args.argi2,
                        (args.argi1 & DONT_REPORT) != 0, args.argi3);
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            } break;
            case PAUSE_ACTIVITY_FINISHING: {
                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
                SomeArgs args = (SomeArgs) msg.obj;
                handlePauseActivity((IBinder) args.arg1, true, (args.argi1 & USER_LEAVING) != 0,
                        args.argi2, (args.argi1 & DONT_REPORT) != 0, args.argi3);
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            } break;
            case STOP_ACTIVITY_SHOW: {
                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStop");
                SomeArgs args = (SomeArgs) msg.obj;
                handleStopActivity((IBinder) args.arg1, true, args.argi2, args.argi3);
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            } break;
            case STOP_ACTIVITY_HIDE: {
                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStop");
                SomeArgs args = (SomeArgs) msg.obj;
                handleStopActivity((IBinder) args.arg1, false, args.argi2, args.argi3);
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            } break;
            ...
            ...
            ...
        }
 
    }

 handleLaunchActivity方法分析

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
    // If we are getting ready to gc after going to the background, well
    // we are back active so skip it.
    unscheduleGcIdler();
    mSomeActivitiesChanged = true;

    if (r.profilerInfo != null) {
        mProfiler.setProfiler(r.profilerInfo);
        mProfiler.startProfiling();
    }

    // Make sure we are running with the most recent config.
    handleConfigurationChanged(null, null);

    if (localLOGV) Slog.v(
        TAG, "Handling launch of " + r);

    // Initialize before creating the activity
    if (!ThreadedRenderer.sRendererDisabled) {
        GraphicsEnvironment.earlyInitEGL();
    }
    WindowManagerGlobal.initialize();
    //执行performLaunchActivity方法，把Activity的信息传递过去返回一个Activity对象
    Activity a = performLaunchActivity(r, customIntent);

    if (a != null) {
        r.createdConfig = new Configuration(mConfiguration);
        reportSizeConfigurations(r);
        Bundle oldState = r.state;
        handleResumeActivity(r.token, false, r.isForward,
                !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);

        if (!r.activity.mFinished && r.startsNotResumed) {
         
            performPauseActivityIfNeeded(r, reason);
            if (r.isPreHoneycomb()) {
                r.state = oldState;
            }
        }
    } else {
        // If there was an error, for any reason, tell the activity manager to stop us.
        try {
            ActivityManager.getService()
                .finishActivity(r.token, Activity.RESULT_CANCELED, null,
                        Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
    }
}

performLaunchActivity()中执行了onCreate和onStart方法，Activity启动起来了

参考博客：https://blog.csdn.net/he6687086/article/details/79173808 （这位大哥写的挺好，容易理解）

love943177923
关注
专栏目录
Android APP及ActivityThread启动流程的一些理解
linnnnn.的博客
08-01 1211
目录系统启动的初始工作System Server进程Launcher进程六个大类ActivityThread启动流程APP启动流程ActivityManagerService相关启动流程图 系统启动的初始工作 1. Android 众多基于Linux内核的系统类似, 启动系统时, bootloader启动内核和init进程. 2. init进程分裂出更多名为"daemons(守护进程)"的底层的Linux进程, 诸如android debug deamon, USB deamon等. 这些守护进程处理底层
深入理解应用主线程ActivityThread
Proton
03-21 781
在ActivityThread中，应用通过持有AMS的代理IActivityManager，和把自己的代理IApplicationThread通过attach函数传递给system_server,来建立一个进程间的双向通信的渠道。通过，Handler,handleMessage,sendMessage,来实现ApplicationThread和ActivityThread线程间通信，把消息发送给主线程，让主线程完成相关生命周期函数调用。
ActivityThread分析
zouguogufunhua的专栏
06-30 417
ActivityThread分析 App进程创建好之后，执行ActivityThread的main方法。 main方法执行如下几项重要工作： 1.主线程的Looper循环初始化，looper对象在对象创建的时候已经创建好了，这里执行Looper.prepareMainLooper(); 2.初始化ActivityThread对象，并执行ActivityThread的attach方法。 attach方法： 1.非system进程，需要调用AMS的attachApplication方法将当前进程的A
java中activeThread_Java ThreadGroup类activeCount()方法及示例
weixin_32018297的博客
02-25 405
ThreadGroup类activeCount()方法activeCount()方法在java.lang包中可用。activeCount()方法是静态方法，也可以使用类名进行访问。activeCount()方法用于返回当前线程线程组中活动线程的数量。当没有活动线程处于活动状态时，activeCount()方法不会引发任何异常。语法：staticintactiveCount();参数：此方法不接...
Activity管理（三）：activity内核管理方案详细讲解
最新发布
2401_86372349的博客
09-04 819
其实Android里所谓的“Activity堆栈”，并不是真正的一个堆栈结构，而是一个ArrayList列表，在这个列表里记录了所有的ActivityRecord，ActivityStack所做的事情就是保证列表的第一个ActivityRecord（也就是“栈顶”）处于运行状态，并且排在列表后面的ActivityRecord的运行状态受到“栈顶”ActivityRecord的影响。我们知道，Activity的管理是以Task为单位来进行的，多个行为类似的Activity会被归类到同一个Task中。
ActivityThread
Android
08-02 753
ActivityThread ActivityThread就是我们常说的主线程或UI线程，ActivityThread的main方法是整个APP的入口。 ActivityThread的初始化 ActivityThread即Android的主线程，也就是UI线程，ActivityThread的main方法是一个APP的真正入口，MainLooper在它的main方法中被创建。 //ActivityThread的main方法 public static void main(String
android 思维导图学习系列（8）- Activity绘制 其中包Activity启动流程和ActivityThread的关系，ActivityThread的具体方法介绍
白日梦奇
06-11 310
android 思维导图学习系列（7）- Activity绘制 其中包Activity启动流程和ActivityThread的关系，ActivityThread的具体方法介绍 ActivityThread是程序的主入口
java中activeThread_Java Thread activeCount()方法
weixin_36072221的博客
02-25 226
Thread类的activeCount()方法用于返回当前线程的线程组中活动线程的数量。返回的值只是一个估计值，因为当此方法遍历内部数据结构时，线程数可能会动态更改。语法public static int activeCount()返回它返回当前线程的线程组中活动线程的数量。示例public class JavaActiveCountExp extends Thread{JavaActiveCou...
Android线程管理之ActivityThread
09-02
理解并熟练掌握这些知识点，对于开发高性能、响应迅速的Android应用程序至关重要。通过合理利用线程管理机制，开发者可以优化应用的性能，提高用户体验，同时避免由于线程不当使用导致的潜在问题。
Android API 28 ActivityThread&ApplicationThread解析
01-03
ActivityThread代表进程的主线程，创建完新进程后ActivityThread.main函数被加载，执行loop的循环使当前线程进入消息循环，且作为主线程。 public static void main(String[] args) { ...... Looper....
从ActivityThread说起Handler相关的对象关系
一切都刚开始
02-10 1294
在提到Handler的时候就不得不提到Looper、MessageQueue这两个对象，到底这些对象和所谓的线程是什么关系呢？它们之间是如何联系在一起的呢？又是如何做到发送消息的呢？这里就是要说明这三个问题的，如果你对这些问题也不能很好的回答出来，那就请继续往下看。这里的思路是从ActivityThread（也就是UI线程）的Looper对象开始，讲这三个对象之间的关系。 首先看ActivityT
一文读懂ActivityThread
sd_zhuzhipeng的专栏
10-21 6053
ActivityThread是什么，是主线程吗？它是如何被创建的，以及它的作用又是什么呢？带着这些问题，我们一起来分析下ActivityThread。 全文分为以下几个部分，大家可根据需求阅读 文章目录ActivityThread是什么ActivityThread对象如何被创建的system_server进程App进程ActivityThread的作用进程ActivityServiceBroadcastReceiverContentProvider总结 ActivityThread是什么 Activit.
java中activeThread_java多线程机制中的Thread和Runnable()区别
weixin_30074763的博客
02-25 460
1、java语言使用Thread类及其子类对象来表示线程，新建的一个线程声明周期中经历 新建、(声明一个线程，此时他已经有了相应的内存空间和其他资源)，运行(线程创建之久就据用了运行的条件，一旦轮到使用CPU，此线程就会脱离创建他的主线程开始自己使命。此线程调用start()方法。通知JVM，这样JVM就会知道一个新的线程排队等候了。子类线程中必须重写Thread父类中的run方法，不然会发生异常...
Activity流程：从ActivityThread开始（一）
qq_37793601的博客
10-19 381
一个activity启动是从activityThread#main开始的，这里省掉一些判断，只看我们需要重点关注的。 public static void main(String[] args) { // 创建一个消息队列 Looper.prepareMainLooper(); //创建一个ActivityThread实例 ActivityThread thread = new ActivityThread(); thread
Android AMS(七) Activity与WMS的连接过程
liu362732346的博客
01-14 1134
概括 我们从两方面来看Activity组件与WindowManagerService服务之间的连接。一方面是从Activity组件到WindowManagerService服务的连接，另一方面是从WindowManagerService服务到Activity组件的连接。从Activity组件到WindowManagerService服务的连接是以Activity组件所在的应用程序进程为单位来进行...
【Android 启动过程】Activity 启动源码分析 ( ActivityThread -＞ Activity、主线程阶段 二 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
09-13 1226
前言、 一、ActivityThread 类 handleLaunchActivity -> performLaunchActivity 方法、 二、Instrumentation.newActivity 方法、 三、AppComponentFactory.instantiateActivityCompat方法、 四、ActivityThread.performLaunchActivity 方法后续细节、 五、Instrumentation.callActivityOnCreate 方法、 总结、
关于ActivityThread类的深入学习
weixin_33828101的博客
02-13 132
activityThread 原文地址: https://www.jianshu.com/p/93c66b3f08d6 android消息机制 https://www.cnblogs.com/all88/p/5430469.html setContentView https://www.cnblogs.com/leipDao/p/7509222.html 转载于:http...
WMS工作原理
weixin_30892037的博客
04-14 341
图1：创建窗口 图2：通信过程 我们知道其实任何一个窗口的创建，最终都是会创建一个 ViewRootImpl对象。ViewRootImpl 是一很重要的类，类似 ActivityThread 负责跟AmS通信一样，ViewRootImpl 的一个重要职责就是跟 WmS 通信，它通过静态变量 sWindowSession（IWindowSession实例）与 WmS 进行通信。...
深入解析Android ActivityThread与线程管理
"深入理解Android线程管理中的ActivityThread机制" 在Android系统中，线程管理是应用程序高效运行的重要组成部分，尤其是主线程，也被称为UI线程。ActivityThread是Android应用程序进程中的核心组件，它扮演着主线...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值