精华内容
下载资源
问答
  • ActivityThread

    2020-08-02 16:01:28
    ActivityThread ActivityThread就是我们常说的主线程或UI线程,ActivityThread的main方法是整个APP的入口。 ActivityThread的初始化 ActivityThread即Android的主线程,也就是UI线程,ActivityThread的main方法是...

    ActivityThread

    ActivityThread就是我们常说的主线程或UI线程,ActivityThread的main方法是整个APP的入口。

    ActivityThread的初始化

    ActivityThread类是Android APP进程的初始类,ActivityThread的main方法是一个APP的真正入口,MainLooper在它的main方法中被创建。

        //ActivityThread的main方法
        public static void main(String[] args) {
            ...
            Looper.prepareMainLooper();
            ActivityThread thread = new ActivityThread();
            //在attach方法中会完成Application对象的初始化,然后调用Application的onCreate()方法
            thread.attach(false);
    
            if (sMainThreadHandler == null) {
                sMainThreadHandler = thread.getHandler();
            }
            ...
            Looper.loop();
            throw new RuntimeException("Main thread loop unexpectedly exited");
        }

    主线程Looper的初始化

    Looper.prepareMainLooper()相关的代码如下:

        主线程Looper的初始化
        public static void prepareMainLooper() {
            prepare(false);
            synchronized (Looper.class) {
                if (sMainLooper != null) {
                    throw new IllegalStateException("The main Looper has already been prepared.");
                }
                sMainLooper = myLooper();
            }
        }
        
        普通线程Looper的初始化
        public static void prepare() {
            prepare(true);
        }
    
        private static void prepare(boolean quitAllowed) {
            if (sThreadLocal.get() != null) {
                throw new RuntimeException("Only one Looper may be created per thread");
            }
            sThreadLocal.set(new Looper(quitAllowed));
        }
    

    看过Handler源码就知道,主线程Looper的初始化和普通线程Looper的初始化很相似,但还是有以下几个区别

     1. 普通线程的Prepare()默认quitAllowed参数为true,表示允许退出,而主线程也就是ActivityThread的Looper参数为false,不允许退出。这里的quitAllowed参数,最终会传递给MessageQueue,当调用MessageQueue的quit方法时,会判断这个参数,如果是主线程,也就是quitAllowed参数为false时,会抛出异常。

        Looper的退时会判断quitAllowed
        void quit(boolean safe) {
            if (!mQuitAllowed) {
                throw new IllegalStateException("Main thread not allowed to quit.");
            }
            synchronized (this) {
                ...
            }
        }
    

    2.我们注意到主线程Looper初始化之后,赋值给了成员变量sMainLooper,这个成员的作用就是向其他线程提供主线程的Looper对象。这下我们就应该知道为什么Looper.getMainLooper()方法能获取主线程的Looper对象。

        public static Looper getMainLooper() {
            synchronized (Looper.class) {
                return sMainLooper;
            }
        }
    

    主线程Handler的初始化

    在ActivityThread的main方法中我们注意到一行代码:

        ActivityThread thread = new ActivityThread();
        thread.attach(false);
        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }
    见名知意,这是获取主线程的Handler,那么主线程的Handler是在什么时候初始化的呢?

        与之相关的代码如下:
        ActivityThread的成员变量
        final H mH = new H();
        
        final Handler getHandler() {
            return mH;
        }
    

    从以上代码中可以看到,主线程的Handler作为ActivityThread的成员变量,是在ActivityThread的main方法被执行,ActivityThread被创建时而初始化,而接下来要说的ApplicationThread中的方法执行以及Activity的创建都依赖于主线程Handler。至此我们也就明白了,主线程(ActivityThread)的初始化是在它的main方法中,主线程的Handler以及MainLooper的初始化时机都是在ActivityThread创建的时候。

    ApplicationThread及Activity的创建和启动

    以上的代码和流程,就是对 MainLooper 和 ActivityThread 的初始化,我们接下来看一下 ActivityThread 的初始化及其对应的 attach 方法,在thread.attach方法中,ActivityManagerService通过attachApplication方法,将ApplicationThread对象绑定到ActivityManagerService,ApplicationThread是ActivityThread的私有内部类,实现了IBinder接口,用于ActivityThread和ActivityManagerService的所在进程间通信。

        ActivityThread的attach方法:
        private void attach(boolean system) {
            ...
            if (!system) {
                final IActivityManager mgr = ActivityManager.getService();
                try {
                    mgr.attachApplication(mAppThread);
                } catch (RemoteException ex) {
                    throw ex.rethrowFromSystemServer();
                }else{
                    ...
                }
            }
        }
        
        ActivityManagerService中的方法:
        public final void attachApplication(IApplicationThread thread) {
            synchronized (this) {
                int callingPid = Binder.getCallingPid();
                final long origId = Binder.clearCallingIdentity();
                attachApplicationLocked(thread, callingPid);
                Binder.restoreCallingIdentity(origId);
            }
        }
        
        这里的个人理解是:在每个ActivityThread(APP)被创建的时候,
        都需要向ActivityManagerService绑定(或者说是向远程服务AMS注册自己),
        用于AMS管理ActivityThread中的所有四大组件的生命周期。
    

    上述AMS的代码中attachApplicationLocked方法比较复杂,主要功能有两个,详见注释,这里忽略了很多代码细节,具体的流程可以看源码

        AMS中的方法,主要功能有以下两步
        private final boolean attachApplicationLocked(IApplicationThread thread, int pid) {
            ...
            主要用于创建Application,用调用onCreate方法
    		thread.bindApplication(...);
    		...
    		主要用于创建Activity
            if (mStackSupervisor.attachApplicationLocked(app)) {
                ...
            }
        }
    

    thread.bindApplication:主要用于创建Application,这里的thread对象是ApplicationThread在AMS中的代理对象,所以这里的bindApplication方法最终会调用ApplicationThread.bindApplication()方法,该方法会向ActivityThread的消息对应发送BIND_APPLICATION的消息,消息的处理最终会调用Application.onCreate()方法,这也说明Application.onCreate()方法的执行时机比任何Activity.onCreate()方法都早。

        ActivityThread中的bindApplication方法
        public final void bindApplication(...) {
            ...
            该消息的处理,会调用handleBindApplication方法
            sendMessage(H.BIND_APPLICATION, data);
        }
        ActivityThread中的handleBindApplication方法
        private void handleBindApplication(AppBindData data) {
            ...
            try {
                Application app = data.info.makeApplication(data.restrictedBackupMode, null);
                mInitialApplication = app;
                ...
                try {
                    mInstrumentation.callApplicationOnCreate(app);
                } catch (Exception e) {
                }
            } finally {
            }
        }
            
        LoadedApk中的方法,用于创建Application
        public Application makeApplication(boolean forceDefaultAppClass, Instrumentation instrumentation) {
            如果存在Application的实例,则直接返回,这也说明Application是个单例
            if (mApplication != null) {
                return mApplication;
            }
    
            Application app = null;
            ...这里通过反射初始化Application
    
            if (instrumentation != null) {
                try {
                    调用Application的onCreate方法
                    instrumentation.callApplicationOnCreate(app);
                } catch (Exception e) {
                }
            }
            return app;
        }
    

    mStackSupervisor.attachApplicationLocked(app):用于创建Activity,mStackSupervisor是AMS的成员变量,为Activity堆栈管理辅助类实例,该方法最终会调用ApplicationThread类的scheduleLaunchActivity方法,该方法也是类似于第一步,向ActivityThread的消息队列发送创建Activity的消息,最终在ActivityThread中完成创建Activity的操作。

        boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
            ...
            if (realStartActivityLocked(hr, app, true, true)) {
                ...
            }          
            ...
        }
    
        final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
                boolean andResume, boolean checkConfig) throws RemoteException {
            ...
            try {
                调用ApplicationThread的scheduleLaunchActivity用于启动一个Activity
                app.thread.scheduleLaunchActivity(...);
            } catch (RemoteException e) {
            }
        }
    
        ApplicationThread的scheduleLaunchActivity方法会向ActivityThread发送LAUNCH_ACTIVITY信息,用于启动一个Activity,该消息的处理会调用ActivityThread的handleLaunchActivity方法,最终启动一个Activity

    以上就是从ActivityThread的main方法执行到Activity的创建之间的流程。

    转载文章:https://blog.csdn.net/hzwailll/article/details/85339714

    展开全文
  • ActivityThread分析

    2020-06-30 02:09:10
    ActivityThread分析 App进程创建好之后,执行ActivityThread的main方法。 main方法执行如下几项重要工作: 1.主线程的Looper循环初始化,looper对象在对象创建的时候已经创建好了,这里执行Looper....

    ActivityThread分析

    App进程创建好之后,执行ActivityThread的main方法。

    main方法执行如下几项重要工作:

    1.主线程的Looper循环初始化,looper对象在对象创建的时候已经创建好了,这里执行Looper.prepareMainLooper();

    2.初始化ActivityThread对象,并执行ActivityThread的attach方法。

    attach方法:

    1.非system进程,需要调用AMS的attachApplication方法将当前进程的ApplicationThread对象传递给AMS,AMS在执行完attachApplication后,会通过ApplicationThread对象执行它的bindApplication方法,然后执行ActivityThread的handleBindApplication方法。

    handleBindApplication方法里面会执行data.info = getPackageInfoNoCheck(data.appInfo, data.compatInfo);,执行到getPackageInfo方法,初始化ApkLoader

    同时执行下列代码final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);

    初始化Application的Context。

     

    展开全文
  • Activitythread笔记

    2019-01-05 19:02:47
    activitythread.main()------------>activitythread.bindApplication()------------->创建了Instrumentation(调用了classloader创建了Instrumentation)--------->在ActivityThread中调...

    //activity的创建过程

    进程启动------->activitythread.main()------------>activitythread.bindApplication()------------->创建了Instrumentation(调用了classloader创建了Instrumentation)--------->在ActivityThread中调用了Instrumentation.newActivity(调用了Classloader创建activity)------------》

     

    //contextimpl的创建过程和activity的绑定过程

    Activitythread创建contextimpl------------------》调用activity.attach------------------>把contextimpl赋值给activity的父类ContextWrapper的mbase对象,并且创建了PhoneWindow对象

     

    //DecorView的创建

    在setContentView中创建了DecorView对象,之后创建了ViewRootImpl对象,调用了ViewRootImpl的setView方法,在setView中调用了mWindowSession.addToDisplay,通过跨进程调用到了wms的addWindow方法

    wms创建WindowState 检查token操作,并且添加到了windowMap队列中。

     

    //activity.startActivity过程

    activity.startactivity----------->调用mbase.startactivity(相当于调用contextimpl.startActivity)------------->调用Instrumentation.execStartActivity----------------->ActivityManagerNative.startActivity----------->调用到了ams

    展开全文
  • ActivityThread

    2017-07-05 10:13:47
    http://blog.csdn.net/myarrow/article/details/14223493ActivityThreadActivityThread类,即代表Application主线程,它管理应用进程的主线程的执行(相当于普通Java程序的main入口...AMS为Client、ActivityThread.App

    http://blog.csdn.net/myarrow/article/details/14223493
    ActivityThread类,即代表Application主线程,它管理应用进程的主线程的执行(相当于普通Java程序的main入口函数),并根据AMS的要求(通过IApplicationThread接口,AMS为Client、ActivityThread.ApplicationThread为Server)负责调度和执行activities、broadcasts和其它操作。主线程的主要责任就是:快速处理UI事件;快速处理Broadcast消息(尽量避免让【主线程】执行耗时的操作,让它能快速处理UI事件和Broadcast消息)

    注意:View组件由UI线程(主线程)所执行。如果需要迅速更新UI画面或UI画图需要较长时间,则需要使用SurfaceView。它可由后台线程(background thread)来执行,而View只能由UI(主)线程执行。SurfaceView内有高效的rendering机制,可以让后台线程快速刷新Surface的内容。
    View —> UI(主)线
    SurfaceView —> 后台线程

    展开全文
  • 关于ActivityThread

    2016-10-30 23:02:25
    ActivityThread的内部类H(handler)负责activity、service声明周期消息的处理、window窗口出现和隐藏消息处理等。main()方法在ActivityThread中,是程序的入口,在main()中开启了looper.loop(),ActivityThread运行...
  • 线程通信、ActivityThread及Thread类是理解Android线程管理的关键。通过本文给大家介绍Android线程管理之ActivityThread 的相关知识,对android线程管理相关知识感兴趣的朋友一起学习吧
  • ActivityThread笔记

    2015-11-26 10:52:59
    Android.app.ActivityThread进程建立后,将跳入到ActivityThread的main函数开始运行,进入消息循环。 代码如下: Step 1. ActivityThread.main() public static void main(String[] args) { ...
  • ActivityThread performLaunchActivity 今天就想单独分析下这个函数,理解这个函数对于我们理解Activity的生命周期还是很有帮助的,这个函数真正执行了Activity的创建,并执行了onCreate函数。 新建Activity...
  • ActivityThread代表进程的主线程,创建完新进程后ActivityThread.main函数被加载,执行loop的循环使当前线程进入消息循环,且作为主线程。 public static void main(String[] args) { ...... Looper....
  • 了解ActivityThread

    千次阅读 2015-11-15 12:45:25
    Activity里面有一个成员变量ActivityThread,也就是Activity的UI主线程。 /** * This manages the execution of the main thread in an * application process, scheduling and executing activities, * ...
  • 1.ActivityThread的启动流程 ActivityThread是应用的主线程/UI线程,其main()方法是app的入口方法。 ActivityThread继承于ClientTransactionHandler。 1.1 ActivityThread.main() public final class ...
  • Android ActivityThread

    2015-10-26 17:58:00
    当启动应用程序时会由ActivityMangerService孵化一个进程,并且实例化一个ActivityThread对象,该类为fianl类型,并不是一个线程类,该类mian()方法实现了常说的消息循环 publicstaticvoidmain(String[]args){ ...
  • 前面我们分析了ActivityThread的main方法是如何被调用的,本篇我们来分析ActivityThread的main方法内的流程。 代码分析 frameworks\base\core\java\android\app\ActivityThread.java#main() public ...
  • ActivityThread ActivityThread就是主线程或UI线程,ActivityThread的main方法是整个APP的入口。 public final class ActivityThread { //... private static ActivityThread sCurrentActivityThread; public...
  • ActivityThread学习

    2014-07-17 11:27:00
    其实android上一个应用的入口,应该是ActivityThread。和普通的java类一样,入口是一个main方法。 public static final void main(String[] args) { SamplingProfilerIntegration.start(); ……...
  • ActivityThread相关源码分析

    千次阅读 2019-02-26 16:08:20
    先看ActivityThread相关类图   分析核心的类:ActivityThread 各个关键类简介:  1、ActivityThread(进程内唯一):负责进程下Application、所有Activity  2、Instrumentation(进程内唯一):作为...
  • public final class ActivityThread {     https://www.devp.com/forum.php?mod=viewthread&tid=38129   主线程中会构造这两个类的对象。 但是他们不是线程,你看看继承关系就可以知道...
  • ActivityThread的main方法解读 public static void main(String[] args) { ... ... //创建Looper Looper.prepareMainLooper(); //创建ActivityThread示例并绑定 ActivityThread thread = new Activity...
  • ActivityThread与ApplicationThread

    千次阅读 2017-06-04 15:59:52
    Android应用ui是绘制在主线程中的,这个线程就是ActivityThread。 但实际上看源码发现ActivityThread并没有继承自Thread,而是一个独立的类,只是在其main方法中开了一个Looper循环消息,不断接收处理发到主线程里面...
  • ActivityThread在Android中它就代表了Android的主线程,但是并不是一个Thread类。 严格来说,UI主线程不是ActivityThreadActivityThread类是Android APP进程的初始类,它的main函数是这个APP进程的入口。APP进程...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,796
精华内容 3,518
关键字:

activitythread