快捷搜索:

您的位置:环球彩票登陆 > 环球彩票登陆 > 为什么我们能在主线程直接使用 Handler,而不需要

为什么我们能在主线程直接使用 Handler,而不需要

发布时间:2019-10-16 18:01编辑:环球彩票登陆浏览(93)

    NDK 模块开辟

    **
     * Initialize the current thread as a looper, marking it as an
     * application's main looper. The main looper for your application
     * is created by the Android environment, so you should never need
     * to call this function yourself.  See also: {@link #prepare()}
     */
    public static void prepareMainLooper() {
        //在主线程中,其默认初始化一个Looper对象,因此我们在主线程的操作中是不需要自己去调prepare()。
        prepare(false);
        synchronized (Looper.class) {
            //这里先进行判断,在主线程是否已经存在Looper了,
            // 避免我们手动去调用prepareMainLooper(),因为这个是给程序入口初始化的时候系统会自动调用的
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            //设置全局变量,主线程的looper
            sMainLooper = myLooper();
        }
    }
    

    这两天去过多集团面试,除了您全数基本的能够写多少个高品质app的技术后,日常都会在和睦的app里面加一些存世的周旋较 666 的技能,这个才具咱们称为前沿技术。他们平日富含热晋级,热修复,App Instant,强制更新,组件化路由架构Arouter,ENCORExJava,IOC架构方法,Hook本领等等,当然,这个手艺你不可能只会用,你必要明白她的规律,有的时候候,你还索要精晓哪些对这个架构进行改正。

    /**
     * Handle system messages here.
     */
    public void dispatchMessage(Message msg) {
        //这里先判断callback是否为空
        // callback就是我们使用handler.post(Runnable r)的入参runnable
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            //如果hanlder的入参callback不为空,优先处理
            if (mCallback != null) {
                //如果回调返回true.则拦截了handler.handleMessage的方法
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            //这就是为什么我们使用hanlder的时候,需要重写handleMessage的方法
            handleMessage(msg);
        }
    }
    

    3 //...

    Looper中,sThreadLocal作为一个全局变量,sThreadLocal其实是保存Looper的二个器皿,大家三翻五次往ThreadLocal的get、set举办剖析。

    11 }

    那样就会不辱职责在子线程创造handler。

    Java语言进级与Android相关本领基础

    //保存一个主线程的looper
    private static Looper sMainLooper;  // guarded by Looper.class
    
    /**
     * Return the Looper object associated with the current thread.  Returns
     * null if the calling thread is not associated with a Looper.
     */
    public static Looper myLooper() {
        //使用当前线程的looper
        return sThreadLocal.get();
    }
    

    4 * is created by the Android environment, so you should never need

    ThreadLocal.java:

    小心:平日大家以为 ActivityThread 就是主线程。事实上它并非二个线程,而是主线程操作的首领士,所以啊,小编以为把 ActivityThread 以为就是主线程没有可过分质问,另外主线程也得以说成 UI 线程。

    Looper.java:

    16}

    看构造器可得,借使在子线程创立handler,必得在子线程中先创造一个Looper对象,不然hanlder在开头化的时候获得不了当前线程的looper,会抛出特别"Can't create handler inside thread that has not called Looper.prepare()"。

    13 sMainLooper = myLooper();

    /**
     * Initialize the current thread as a looper, marking it as an
     * application's main looper. The main looper for your application
     * is created by the Android environment, so you should never need
     * to call this function yourself.  See also: {@link #prepare()}
     */
    public static void prepareMainLooper() {
        //在主线程中,其默认初始化一个Looper对象,因此我们在主线程的操作中是不需要自己去调prepare()。
        prepare(false);
        synchronized (Looper.class) {
            //这里先进行判断,在主线程是否已经存在Looper了,
            // 避免我们手动去调用prepareMainLooper(),因为这个是给程序入口初始化的时候系统会自动调用的
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            //设置全局变量,主线程的looper
            sMainLooper = myLooper();
        }
    }
    

    14

    1.怎么在主线程中创制Handler无需我们调用Looper.prepare().因为在程序的输入中系统会调用Looper.prepareMainLooper()来创建,而且让其主线程的Looper运营起来。假若大家在子线程创造handler,要求手动创造looper何况运维。

    环球彩票登陆 1

    再看回以前的代码:
    looper.java:

    8 prepare;

    Handler:音讯的管理者,工厂中流水线的工人。
    Message:系统传递的新闻,工厂中流水生产线上的出品。
    MessageQueue:音讯队列,工厂中流水生产线上的传递带。
    Looper:内燃机,工厂中使流水生产线的传递带移动的引擎。

    7 thread.attach;

    private static void prepare(boolean quitAllowed) {
        //先判断当前线程是否已经存在Looper了,如果存在,不允许设置新的Looper对象,一个线程只允许存在一个Looper
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        //在当前线程中,创建新的Looper对象,并绑定当前线程
        sThreadLocal.set(new Looper(quitAllowed));
    }
    

    群内还应该有为数不少无需付费的关于高阶安卓学习资料,包罗高端UI、品质优化、框架结构师课程、 NDK、混合式开垦:ReactNative Weex等多个Android技艺知识的架构录制素材,还应该有专门的工作生涯规划及面试指点。

    Looper.prepare(boolean)的职能正是创制一个Looper对象,并与近来线程绑定在一块儿。在代码中,首先决断当前线程是或不是业已存在looper,假使不设有则创设新的looper并且绑定到如今的线程上。

    2public static void main(String[] args) {

    代码十分长,大家挑关键的代码来看,在代码中本身已写上讲授,在main函数中,Looper调用了prepareMainLooer(),我们再走入Looper看看。

    在 ActivityThread.main() 方法中有如下代码: 1//android.app.ActivityThread

    1.Handler、Looper、Thread有如何关系?
    2.为啥在子线程创立handler会抛相当 "Can't create handler inside thread that has not called Looper.prepare()"?
    3.什么利用handler来管理message?
    4.怎么无法在子线程更新UI?

    环球彩票登陆 2

    ActivityThread.java:

    10 if (sMainLooper != null) {

    3.Handler得以经过通过post或然sendMessage举办发送音讯,因为其最终会调用sendMessageDelayed,大家得以因此runnable情势仍旧重写handleMessage实行新闻的拍卖,当然要是经过handler.sendMessage(msg)的法子的话,大家得以兑现Callback接口抵达新闻的拍卖。

    6 */

    我们一而再看回来大家的Looper.loop()
    Looper.java:

    7public static void prepareMainLooper() {

       public static void main(String[] args) {
            ......
    
            //在android应用程序的入口其实在ActivityThread的main方法
            //在这里,主线程会创建一个Looper对象。
            Looper.prepareMainLooper();
    
            ......
            ......
            ......        
            //执行消息循环
            Looper.loop();
    
            throw new RuntimeException("Main thread loop unexpectedly exited");
        }
    }
    

    3 * application's main looper. The main looper for your application

    在选择程序ActivityThread.main入口中,系统除去调用Looper.prepareMainLooper,並且在结尾还调用了Looper.loop(),那个函数有啥样?大家脑补一下,工厂里的流程上,除了有传送带外,若是你不让它动起来,那传送带也没怎么成效,那么Looper.loop的职能正是让这么些传送拉动起来,相当于我们的让我们的信息队列动起来。

    Looper.prepareMainLooper(); 代码如下: 1/**

    在dispatchMessage函数中,意思正是散发这几个新闻,在代码中先判别msg.callback是不是为空,msg.callback是什么?在上一篇文章已详细介绍过了,其实就是handler.post中的runnable对象,通俗的来讲正是handler即便有post操作的,就管理post的操作,我们在拜望handlerCallback这些函数。
    Handler.java:

    各类Handler 的线程皆有一个 Looper ,主线程当然也不例外,然而大家从不计划过主线程的 Looper 而得以直接使用,这是怎么?

    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        //在message中放一个标记
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        //在这里把消息放到队列里面去
        return queue.enqueueMessage(msg, uptimeMillis);
    }
    

    6 ActivityThread thread = new ActivityThread();

    4.为啥不能够在子线程更新UI?其实更加准确的来讲应该是UI只好在创造UI的线程中实行翻新,也正是主线程,要是子线程创立UI,其能够在子线程举办创新。

    环球彩票登陆 3

    我们承袭往下看,有个prepare(boolean)函数,我们去探视这几个到底是用来干什么的。
    Looper.java:

    11 throw new IllegalStateException("The main Looper has already been prepared.");

    Initialize the current thread as a looper, marking it as an* application's main looper. The main looper for your application* is created by the Android environment, so you should never need* to call this function yourself.

    接下去小编做了有些有关高阶安卓的读书质地及思路,希望能够扶助到咱们学习进步技巧。

    咱俩看见关键的代码:
    Thread t=Thread.currentThread();

    9 if (sMainThreadHandler == null) {

    //关键点,这里的msg.target也就是hanlder.看回代码hanlder.enqueueMessage()
    msg.target.dispatchMessage(msg);
    

    架构师不是原始的,在Android里面最常用的架构无外乎 MVC,MVP,MVVM,不过那个思虑一旦和模块化,等级次序化,组件化混和在一道,那就不是一件那么粗略的事了,大家须求一个当真身经百战的架构师技术讲授深透此中蕴藏的深理。

    我们先从程序入口来进行解析,Android应用程序的输入在ActivityThread的main函数中,我们先从main函数进行剖析:

    9 synchronized (Looper.class) {

    msg.target其实就是我们的handler,无论是handler通过post也许sendEmptyMessage,最后都会调用到调到这一个enqueueMessage(),在这里地会将handler赋值到msg.target中.

    Android前沿能力

    小心这几个函数的注释,大约意思是:在主线程创制三个looper,是这些主线程的主looper,当这些app在开首化的时候就能够活动创设,由此那一个函数不是给您们调用的,是给系统本身在程序创造的时候调用的。

    14 }

    /**
     * 调用此函数用于启动消息队列循环起来,作用相当于工厂流水线中的传送带的开关,
     * 只有把开关打开,传送带才跑起来
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     */
    public static void loop() {
        .....
        .....
        //循环通过消息队列来获取消息
        for (; ; ) {
            ......
            //最后回收这个message
            msg.recycleUnchecked();
        }
    }
    

    12 //...

    咱俩带着主题材料去看源码:

    Android应用是由Java语言实行支付的,SDK也是由Java语言编写,所以大家要上学java语言。另外,虽说kotlin语言获得了Android官方的热推,可是kotlin也是编写翻译成了java语言再运维的。对于Android来讲,只要SDK未有用kotlin重写,那么Java语言是都急需学习的。何况Android apk的后台服务器程序大致率是java语言构建,所以读书java也是一种必然。

    /**
     * 模拟开始
     */
    private void doSth() {
        //开启个线程,处理复杂的业务业务
        new Thread(new Runnable() {
            @Override
            public void run() {
                //模拟很复杂的业务,需要1000ms进行操作的业务
                ......
                handler.post(new Runnable() {
                    @Override
                    public void run() {
                        //在这里可以更新ui
                        mTv.setText("在这个点我更新了:"   System.currentTimeMillis());
                    }
                });
            }
        }).start();
    }
    

    2 * Initialize the current thread as a looper, marking it as an

    new Thread(new Runnable() {
        @Override
        public void run() {
            //在当前子线程创建一个Looper对象
            Looper.prepare();
            Handler handler=new Handler();
            //让消息队列动起来
            Looper.loop();
        }
    }).start();
    

    5

    Looper.java:

    5 * to call this function yourself. See also: {@link #prepare()}

    Looper.java:

    能够阅览在 ActivityThread 里 调用了 Looper.prepareMainLooper() 方法成立了 主线程的 Looper ,并且调用了 loop() 方法,所以大家就足以向来动用 Handler 了。

    世家先对一下的对象,脑补一下厂子的场地:

    8

    /**
     * Callback interface you can use when instantiating a Handler to avoid
     * having to implement your own subclass of Handler.
     *
     * @param msg A {@link android.os.Message Message} object
     * @return True if no further handling is desired
     */
    public interface Callback {
        public boolean handleMessage(Message msg);
    }
    
    /**
     * Constructor associates this handler with the {@link Looper} for the
     * current thread and takes a callback interface in which you can handle
     * messages.
     * <p>
     * If this thread does not have a looper, this handler won't be able to receive messages
     * so an exception is thrown.
     *
     * @param callback The callback interface in which to handle messages, or null.
     */
    public Handler(Callback callback) {
        this(callback, false);
    }
    

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

    总结:

    环球彩票登陆 4

    /**
     * 调用此函数用于启动消息队列循环起来,作用相当于工厂流水线中的传送带的开关,
     * 只有把开关打开,传送带才跑起来
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     */
    public static void loop() {
        //先进行判断当前线程是否有绑定looper
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        //获取这个looper的消息队列
        final MessageQueue queue = me.mQueue;
    
        // Make sure the identity of this thread is that of the local process,
        // and keep track of what that identity token actually is.
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();
    
        //循环通过消息队列来获取消息
        for (; ; ) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
    
            // This must be in a local variable, in case a UI event sets the logger
            final Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to "   msg.target   " "  
                        msg.callback   ": "   msg.what);
            }
    
            final long traceTag = me.mTraceTag;
            if (traceTag != 0) {
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
            }
            try {
                //关键点,这里的msg.target也就是hanlder.看回代码hanlder.enqueueMessage()
                msg.target.dispatchMessage(msg);
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
    
            if (logging != null) {
                logging.println("<<<<< Finished to "   msg.target   " "   msg.callback);
            }
    
            // Make sure that during the course of dispatching the
            // identity of the thread wasn't corrupted.
            final long newIdent = Binder.clearCallingIdentity();
            if (ident != newIdent) {
                Log.wtf(TAG, "Thread identity changed from 0x"
                          Long.toHexString(ident)   " to 0x"
                          Long.toHexString(newIdent)   " while dispatching to "
                          msg.target.getClass().getName()   " "
                          msg.callback   " what="   msg.what);
            }
            //最后回收这个message
            msg.recycleUnchecked();
        }
    }
    

    13 Looper.loop();

    因此,假如大家在子线程中成立Handler的时候,大家得以这么:

    4 Looper.prepareMainLooper();

    相当于说,大家的Looper对象分别保存在相对应的线程中。大家看回来大家的prepare(boolean)函数:
    looper.java:

    12 }

    在这里地,大家看来了sThreadLocal,大家先看看那些sThreadLocal在Looper是怎么用的。

    10 sMainThreadHandler = thread.getHandler();

    但注意从前大家所观看的,借使大家mCallback.handlerMessage(msg)再次来到为true的话,那样就不交付handler.handleMessage管理了。

    急需那些材质的我们关切 私信回复“安卓资料”无偿获取!

    2.每二个线程只可以存在三个Looper, Looper有三个全局变量sThreadLocal用来保存每三个线程的looper,通过get、set进行存取looper。

    一抬手一动脚架构师

    很简短,就一行代码,大家来看了听得多了就能说的详细的run方法,那几个不正是大家利用post的时候传进去的Runnbale对象的run方法吗?

    15}

    在最棒循环每一个新闻的时候,除了调用handler.dispatchMessage,最终还会调用msg.recycleUnchecked()实行回收这么些音讯,至于message怎么回收大家就不切磋了,实际情况的豪门能够去看看自个儿上一篇小说。

    当心:Looper.loop() 是个死循环,前边的代码平常情状不会执行。

    ActivityThread.java:

    音录像/高清大图片/人工智能/直播/抖音等等这一年与顾客最严苛,与我们生存最相关的手艺平昔都在探寻最后的本事诞毕生台,从前是windows系统,而前天则是运动系统了,移动系统中又是以Android占比绝大部分为前提,所以Android NDK手艺已然是大家必备手艺了。

    注:
    网络也许有大多篇章关于Android音讯机制的稿子,大神们都写得很彻底,但为啥作者还要去写这么的篇章,一方便想经过读源码来增加个人的求学本事,另一方面也想将自身学到的享受给大家,哪怕多年之后看回本身的博客,也是别有一番滋味。从14年起来出来做android,看了广大稿子,学到了无数东西,小编很敬佩他们。非常多谢郭霖、李纪钢、徐宜生等等,因为他俩的忘笔者分享让无数人在职业上缓慢解决了累累难点,因而笔者也可望自身能形成那样的人。

    Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            //处理消息
        }
    };
    

    这一段代码比较长,大家挑有汉语注释的来看,先决断当前的线程是还是不是存在looper,假诺存在获得保存在Looper的消息队列messagequeue,然后Infiniti循环那么些消息队列来获得message,注意大家留到了一段代码:

    public static void main(String[] args) {
        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
        SamplingProfilerIntegration.start();
    
        // CloseGuard defaults to true and can be quite spammy.  We
        // disable it here, but selectively enable it later (via
        // StrictMode) on debug builds, but using DropBox, not logs.
        CloseGuard.setEnabled(false);
    
        Environment.initForCurrentUser();
    
        // Set the reporter for event logging in libcore
        EventLogger.setReporter(new EventLoggingReporter());
    
        // Make sure TrustedCertificateStore looks in the right place for CA certificates
        final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
        TrustedCertificateStore.setDefaultUserDirectory(configDir);
    
        Process.setArgV0("<pre-initialized>");
    
        //在android应用程序的入口其实在ActivityThread的main方法
        //在这里,主线程会创建一个Looper对象。
        Looper.prepareMainLooper();
    
        ActivityThread thread = new ActivityThread();
        thread.attach(false);
    
        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }
    
        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }
    
        // End of event ActivityThreadMain.
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        //执行消息循环
        Looper.loop();
    
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }
    

    Handler.java:

    /**
     * Returns the value in the current thread's copy of this
     * thread-local variable.  If the variable has no value for the
     * current thread, it is first initialized to the value returned
     * by an invocation of the {@link #initialValue} method.
     *
     * @return the current thread's value of this thread-local
     */
    public T get() {
        //获取当前线程保存的对象--通过get函数来获取Looper对象
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null)
                return (T) e.value;
        }
        return setInitialValue();
    }
    
    /**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Most subclasses will have no need to
     * override this method, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current thread's copy of
     *              this thread-local.
     */
    public void set(T value) {
        //把当前的looper保存到当前线程中
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
    
    // sThreadLocal.get() will return null unless you've called prepare().
    //sThreadLocal在Looper中作为全局变量,用于保存每个线程中的数据,可以看做是容器
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    
    private static void prepare(boolean quitAllowed) {
        //先判断当前线程是否已经存在Looper了,如果存在,不允许设置新的Looper对象,一个线程只允许存在一个Looper
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        //在当前线程中,创建新的Looper对象,并绑定当前线程
        sThreadLocal.set(new Looper(quitAllowed));
    }
    

    末段一行代码中,我们看看了熟知的handleMessage,那不就是大家日常handler.handlerMessage的格局呢?
    Demo:

    Handler.java:

    sMainLooper在Looper做为二个全局变量,保存主线程绑定的looper,myLooper()则是获得当前线程绑定的Looper。在prepareMainLooper()中,在主线程中开创三个新的Looper,何况绑定主线程中,同一时候把那个主线程的looper赋值给sMainLooer那一个全局变量。

    既然Looper中的loop()调用了msg.target.dispatchMessage,我们就看看Handler的dispatchMessage是怎样进行处理那几个msg的。

    Handler.java:

    大家回来handler.dispatchMessage(Message)中,如若不是经过post那么callback就为空,大家看出了一个mCallback变量,大家看看那个Callback的概念:

    近期咱们向后看看自家前边说的那2个难点:为啥子线程创设handler会抛相当?
    咱俩先看看Handler的重要的构造器:

    The callback interface in which to handle messages, or null.
    作者们能够透过落到实处这一个接口,并视作多个参数字传送进去Handler来到达拍卖这些音信的功用。

    在此以前写了一篇有关Message的篇章,感兴趣的朋友能够去看一下【Android新闻机制之Message深入分析(面试)】,那壹次大家来聊一下音信机制中用得最多的Handler,也是面试中问得最多的之一,在那间自身先抛多少个难题出来:

    private static void handleCallback(Message message) {
        message.callback.run();
    }
    
    /**
     * Default constructor associates this handler with the {@link Looper} for the
     * current thread.
     * <p>
     * If this thread does not have a looper, this handler won't be able to receive messages
     * so an exception is thrown.
     */
    public Handler() {
        this(null, false);
    }
    
    /**
     *......
     */
    public Handler(Callback callback, boolean async) {
        if (FIND_POTENTIAL_LEAKS) {
            final Class<? extends Handler> klass = getClass();
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                    (klass.getModifiers() & Modifier.STATIC) == 0) {
                Log.w(TAG, "The following Handler class should be static or leaks might occur: "  
                        klass.getCanonicalName());
            }
        }
    //获取当前线程的looper
         mLooper = Looper.myLooper();
    //如果当前线程没有绑定looper则抛异常
        if (mLooper == null) {
            throw new RuntimeException(
                    "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }
    

    各自看一下sMainLooper是怎么,myLooper()又是怎么?
    Looper.java:

    /**
     * Handle system messages here.
     */
    public void dispatchMessage(Message msg) {
        //这里先判断callback是否为空
        // callback就是我们使用handler.post(Runnable r)的入参runnable
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            //如果hanlder的入参callback不为空,优先处理
            if (mCallback != null) {
                //如果回调返回true.则拦截了handler.handleMessage的方法
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            //这就是为什么我们使用hanlder的时候,需要重写handleMessage的方法
            handleMessage(msg);
        }
    }
    

    本文由环球彩票登陆发布于环球彩票登陆,转载请注明出处:为什么我们能在主线程直接使用 Handler,而不需要

    关键词: 环球彩票登陆 日记本 Android... 能在 而不