Android中Looper的实现原理，为什么调用Loope_百度笔试题

推荐

J_蓝弦

1、线程间通信机制

首先，looper、handler、messagequeue三者共同实现了android系统里线程间通信机制。如在A、B两个子线程之间需要传递消息，首先给每个子线程绑定一套handler、looper、messagequeue机制，然后这三个对象都与其所属线程对应。然后A线程通过调用B线程的Handler对象，发送消息。这个消息会被Handler发送到B线程的messagequeue中，而属于B线程的Looper对象一直在for循环里无限遍历MessageQueue, 一旦发现该消息队列里收到了新的消息，就会去对消息进行处理，处理过程中会回调自身Handler的heandleMessage方法。从而实现了不同线程间通信。

2、Looper实现原理

Looper类里包含一个消息队列对象和一个线程对象。当创建Looper时，会自动创建一个消息队列，同时将内部线程对象指向创建Looper的线程。当开启Looper后(looper.loop())，会自动进入无限for循环中，不断去遍历消息队列，如果没有消息则阻塞，有消息则回调handler的handlemessage方法进行处理。

3、Looper.prepare()

首先，要使用Looper机制一般会在当前线程中创建Handler对象，里面会自动创建一个looper对象和消息队列，这里面的消息队列属于当前线程空间。但此时的looper还不会去遍历，也没有绑定到当前线程。其中，looper对象内部也包含一个空消息队列对象和空线程。通过Looper.prepare()方法，先让该消息队列指向当前线程的消息队列，让空线程也指向当前线程。从而实现了绑定。

编辑于 2015-09-14 12:18:14 回复(13)

myronlee

Android提供的Looper、MessageQueue可以帮助我们实现流水线工作的线程

核心类就是Looper啦

题中问线程是如何关联上一个Looper对象的

首先Looper对象会保存一个与之关联的线程的引用

看代码：mThread = Thread. currentThread () ;

然后呢，再把自己变成线程的局部变量
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
··· sThreadLocal.set(new Looper(quitAllowed));

这样它们就关联起来了

编辑于 2015-08-31 20:57:47 回复(0)

咸鱼吧，后浪！

图片说明

首先看下prepare（）的源码，注意到sThreadLocal，Looper正是通过ThreadLocal来获取到当前线程的looper对象的。下面讲下ThreadLocal类的特性：

ThreadLocal是线程内部的数据存储类,当使用ThreadLocal维护变量的时候，它会为每个使用该变量的线程提供一个独立的变量副本，这个变量副本是该线程独有，不受其他线程影响。

因此当Looper的prepare（）中调用
sThreadLocal.get()时，就获取到了当前线程的一个独有的Looper对象，即在在当前线程关联了一个Looper对象，Looper的实现正是巧妙利用了Threadlocal的特性来实现的，避免了去使用哈希表来维护不同线程及其对应Looper的映射关系。

参考：

《Android开发艺术探索》p375
彻底理解ThreadLocal

发表于 2017-09-04 11:52:15 回复(0)

SmallWang

## 问答题 ##
Android中Looper的实现原理，为什么调用Looper.prepare()就在当前线程关联了一个Looper对象，它是如何实现的。

- 首先该问题，有三个子问题，a Looper实现原理，b 调用Looper.prepare()就在当前线程关联了一个Looper对象， c 它是如何实现的，这个它是谁？我认为是Looper.prepare() 关联Looper对象。
- a.Looper实现原理
    - Looper可以理解为一个类似轮询器
    - Looper在创建的时候，会自动创建一个MessageQueue(消息队列)，和一个线程。
    - 将内部线程对象指向自动创建的线程。
    - 然后当Looper开启的时候，去不断遍历“询问”消息队列，如果没有消息，队列为空，那么就继续轮询。如果有消息进入队列，则对消息进行处理，回调handler的handlemessage方法进行处理
    - 这样就完成了线程通信的一部分
- b.c.Looper.prepare()方法关联一个Looper对象
    - 首先逗逼一下的说，问我为什么，肯定会说是系统设计或者方法设计的要求啊，2333，用了Looper.prepare就是会关联Looper对象，2333
    - 那么要考虑一个问题，Looper.prepare()是谁执行这个方法，是一个Looper对象，那么关联的Looper对象是谁？
    - 在相关源码里有注释如下：初始化当前线程作为一个looper，在looper开始之前，参考这个looper，去创建一个handlers。然后一堆不知所云，2333
    - 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)); }
    - 看上面的方法，我们看到prepare针对不同的参数，又不一样的重构方法，但是通过一步步调用，我们还是看到了sThreadLocal.set(new Looper(quitAllowed))；
    - prepare方法中会调用一个prepare(true)--->之后去set一个新new的Looper对象
    - 那么为什么呢？是因为源码里就这样用的？到底怎么梳理总结呢？
    - threadLocal是线程内部的数据储存类，储存了一个线程的相关信息。线程关联一个(set)looper对象之后，通过looper的loop方法，再低通threadLocal的get方法，可以将之前关联的对象提取出来，对该对象的messageQueue进行轮询。
    - 每一个线程都有一个独立的looper，去轮询相应的消息队列。
- c.假如问的是这一堆是如何实现的
    - 在进行通信时，我们每一个线程都会有自己对应的handler,looper,messagequeue
    - 两个线程要通信，那么一线程调用二线程的Handler对象，发送消息。这个消息会被Handler发送到二线程的Messagequeue，同时被二线程的looper轮询到，然后处理，用二线程的handlenMessage方法

发表于 2016-08-07 19:06:53 回复(0)

山有木木有枝

想说的是Looper.prepare（）？该方法调用Looper的构造，Looper()中新建MessageQueue和绑定当前的Thread。

源码地址

：http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/5.0.2_r1/android/os/Looper.java#Looper.prepare%28%29

发表于 2015-03-08 22:57:24 回复(0)

味觉

 /** Initialize the current thread as a looper.  * This gives you a chance to create handlers that then reference  * this looper, before actually starting the loop. Be sure to call  * {@link #loop()} after calling this method, and end it by calling  * {@link #quit()}.  */ 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)); }

直接贴上源码咯，关联的话，主要是通过，sThreadLocal的set方法进行关联的，而threadLocal是线程内部的数据存储类，该类存储了线程的所有数据信息。

/**  * Sets the value of this variable for the current thread. If set to  * {@code null}, the value will be set to null and the underlying entry will  * still be present.  *  * @param value the new value of the variable for the caller thread.  */ public void set(T value) {
    Thread currentThread = Thread.currentThread();  Values values = values(currentThread);  if (values == null) {
        values = initializeValues(currentThread);  }
    values.put(this, value); }

存储了相关的信息后，通过looper的loop()方法，调用threadLocal的get()方法再把之前新创建的looper对象提取出来，对looper对象中messageQueue进行轮询信息，查询到有消息就调用handler的dispatchMessage()分发消息出去，这时候就会响应handlerMessage，实现跨线程通信了。

总的来说，handler调用sendMessage，就往handler的messageQueue里装消息，而messageQueue就是恰好就是装进在初始化handler的那个looper环境中的，一般在UI主线程中会默认创建了looper，但是在子线程，需要为handler独立创建messageQueue空间，这样，使得调用sendMessage时，能够有地方放message。

调用Looper.loop()会获取到相应的messageQueue，将会丢其信息进行轮询操作，一旦接收到message到来，就会响应message.target即目标handler的handlerMessage，消息到这里算是处理完毕。

最为关键是使用了ThreadLocal来存储不同的looper，这样，每个线程都有一个独立的looper，这样，对应的handler才能处理相关的信息。

发表于 2016-02-24 19:55:41 回复(0)

notlie

prepare方法源码

可以看出new了一个Looper的实例并用ThreadLocal进行存储。

至于当前线程是如何关联这个Looper对象，可以看ThreadLocal源码：

ThreadLocal实例调用set方法时首先判断成员变量map指针是否为空，非空则直接以该ThreadLocal对象为键，存储Looper实例。

指针为空则创建ThreadLocalMap实例并赋值给当前线程的threadLocals成员变量，这样当前线程通过关联该map间接地关联Looper实例。

发表于 2015-09-04 16:53:44 回复(0)

wb

Looper.prepare()方法是将当前线程绑定一个looper实例，并存储在TreadLocal中，一个线程只有一个looper对象。

looper中，有一个messagequeue，即消息队列；

handler可以通过sendmessage 等方法向队列中发送消息。

一个线程中可以有多个handler,handler 绑定当前线程的looper对象，以及其中的消息队列；

looper.loop()方法即循环调用MQ中的message，并且调用方送它的handler来处理它。

发表于 2015-04-21 18:06:16 回复(0)

oow

Looper内部有一个ThreadLocal数据结构存放Looper的集合，key是当前线程，value是Looper，当调用prepare（）时，回去ThreadLocal里面查找是否存在当前线程的looper,如果存在则取出，不存在则创建新的Looper，并存入ThreadLocal；由于主线程Looper实在ActivityThread启动时的main方法中已经调用了，所以自动给UI线程关联上Looper

发表于 2018-03-20 16:14:16 回复(0)

无名huster

推荐的答案有问题：创建handler会自动创建一个looper？搞笑。。看过源码么？自己在非UI线程去写代码试试，不报异常崩溃算我傻。。

Looper负责管理消息队列，主要方法是looper.prepare和looper.loop方法

Looper.prepare方法：

首先得到当前线程的threadLocal对象，从当前ThreadLocal对象中获取looper对象，如果为空，则新建一个looper对象，之后存储在当前thread对象的threadLoacal对象中。

Looper.loop方法

核心是一个for的死循环，在该循环中主要有两个地方值得注意：1. 一直调用messageQueue的next方法（一直在从消息队列取出消息）2. 对于取出的Message交给：msg.target.dispathMessage(Message message)去执行，实际上就是又交给了handler去处理了。

发表于 2017-08-24 20:26:25 回复(0)

孙强Jimmy

1、线程间通信机制

首先，Looper、Handler、MessageQueue三者共同实现了Android系统里线程间通信机制。如在A、B两个子线程之间需要传递消息，首先给每个子线程绑定一套Looper、Handler、MessageQueue机制，然后这三个对象都与其所属线程对应。然后A线程通过调用B线程的Handler对象，发送消息。这个消息会被Handler发送到B线程的MessageQueue中，而属于B线程的Looper对象一直在for循环里无限遍历MessageQueue, 一旦发现该消息队列里收到了新的消息，就会去对消息进行处理，处理过程中会回调自身Handler的handleMessage方法，从而实现了不同线程间通信。

2、Looper实现原理

Looper类里包含一个消息队列对象和一个线程对象。当创建Looper时，会自动创建一个消息队列，同时将内部线程对象指向创建Looper的线程。当开启Looper后(Looper.loop())，会自动进入无限for循环中，不断去遍历消息队列，如果没有消息则阻塞，有消息则回调Handler的handleMessage方法进行处理。loop方法唯一跳出循环的方式是MessageQueue的next方法返回了null。当Looper的quit方法被调用时，Looper就会调用MessageQueue的quit或者quitSafely方法来通知消息队列退出，当消息队列被标记为退出状态时，它的next方法就会返回null。

3、Looper.prepare()

首先，要使用Looper机制一般会在当前线程中创建Handler对象，里面会自动创建一个Looper对象和消息队列，这里面的消息队列属于当前线程空间。但此时的Looper还不会去遍历，也没有绑定到当前线程。其中，Looper对象内部也包含一个空消息队列对象和空线程。通过Looper.prepare()方法，先让该消息队列指向当前线程的消息队列，让空线程也指向当前线程，从而实现了绑定。

发表于 2017-03-31 15:48:01 回复(0)

quentain

答：android中的Looper是一个消息处理机制，一个handler创建必须有一个looper，handler里面有messageQueue和Looper.messageQueue负责存储消息队列，looper是负责去消息队列里面查看是否有新的消息需要处理，如果需要，则由looper处理交给handler中的dispatchmessage来处理。而在android中的主线程中默认生成了looper对象，因此可以创建handler.但是在子线程中创建handler之后必须主动的去创建looper对象，因此需要使用looper.prepare().接着开启looper对象就是looper.loop();

发表于 2016-04-19 07:47:08 回复(0)

牛客574609号

    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));

}

发表于 2016-04-12 19:55:52 回复(0)

whx2010nj

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));

}

private Looper(boolean quitAllowed) {

mQueue = new MessageQueue(quitAllowed);

mThread = Thread.currentThread();

}

发表于 2016-04-01 23:02:04 回复(0)

Hello_World!

2、Looper实现原理

Looper类里包含一个消息队列对象和一个线程对象。当创建Looper时，会自动创建一个消息队列，同时将内部线程对象指向创建Looper的线程。当开启Looper后(looper.loop())，会自动进入无限for循环中，不断去遍历消息队列，如果没有消息则阻塞，有消息则回调handler的handlemessage方法进行处理。

3、Looper.prepare()

首先，要使用Looper机制一般会在当前线程中创建Handler对象，里面会自动创建一个looper对象和消息队列，这里面的消息队列属于当前线程空间。但此时的looper还不会去遍历，也没有绑定到当前线程。其中，looper对象内部也包含一个空消息队列对象和空线程。通过Looper.prepare()方法，先让该消息队列指向当前线程的消息队列，让空线程也指向当前线程。从而实现了绑定。

发表于 2016-04-01 21:08:07 回复(0)

牛客778217号

线程创建时默认是不会自动创建一个Looper对象的，Ui线程除外，它会在创建时自动产生一个Looper对象。在子线程中，如果要创建一个Looper对象，使用Looper.prepare()就会调用Looper的构造函数，然后产生一个Looper对象，而且构造函数中会产生一个对应的MessageQueue，这样当主线程创建一个Handler对象时，关联到Looper对象后，便形成了一个内部消息循环系统。

发表于 2016-03-29 15:46:31 回复(0)

Cristinao

Android中线程间的通信机制是通过Looper、Handler、MessageQueue来实现的。

Looper的实现原理：Looper类中包含一个线程对象和一个消息队列对象。Looper的构造方法中创建一个消息队列，同时将内部线程对象指向创建Looper的线程。当Looper.loop()方法开启后，会自动进入无限for循环中，不断的遍历异步消息队列，如果没有消息则阻塞，有消息的话则回调Handler的handleMessage方法来进行处理。

Looper的prepare方法中首先去检查Looper对象是否已经创建，如果已经创建则抛出异常，说明Looper.prepare方法只能被调用一次，同时也保证了一个线程只有一个Looper实例。

发表于 2016-03-25 10:07:13 回复(0)

唐子玄

1.Looper和当前线程的关联表现为Looper的mThread成员变量被赋值为当前线程 
    private Looper(boolean quitAllowed)
    {
        //新建消息队列
        mQueue = new MessageQueue(quitAllowed);
        //获得当前线程
        mThread = Thread.currentThread();
    }
2.当前线程和Looper的关联表现为Thread的localValues成员变量被赋值
这个变量用于保存键值对,对于Android消息机制来说,键就是ThreadLocal实例,值就是Looper实例。
使用ThreadLocal还保证了一个线程只能有一个Looper,
因为prepare()实现中先取当前线程取Looper实例,当没有取到时才新建Looper实例。 
    private static void prepare(boolean quitAllowed)
    {
        //如果当前线程已经有Looper则抛出异常
        if (sThreadLocal.get() != null)
        {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        //将Looper实例赋值给当前线程的localValues成员变量
        sThreadLocal.set(new Looper(quitAllowed));
    }

发表于 2015-12-18 08:45:37 回复(0)

大河儿马

looper类中有ThreadLocal<Looper>线程局部变量，Looper.prepare()方法中：new了一个Looper对象，并放入ThreadLocal<Looper>，从而线程变量中就有了Looper，looper就和线程关联起来了。

此外，Handler也是通过 ThreadLocal<Looper>来get的Looper对象，使他俩关联起来

发表于 2015-11-24 17:05:42 回复(0)

callmehan

<div> if(sThreadLocal.get()!=null){ </div> <div>     throw new RuntimeException("Only one looper can be created per thread");<br /> </div> <div>     <strong></strong>sThreadLocal.set(new Looper()); </div> <div> } </div>

发表于 2015-09-02 21:18:51 回复(0)

就叫我八默哥吧

<div> 调用Looper的prepare（）方法为当前线程创建了一个Looper实例，并创建配套的MessageQueue。 </div> <div> prepare（）方法保证每个线程最多只有一个Looper对象，prepare（）方法的源代码如下： </div> <div> public static final void prepare() </div> <div> { </div> <div>     if(sThreadLocal.get()!=null)<br /> </div> <div>     { </div> <div>         throw new RuntimeException("Only one Looper may be created per thread");<br /> </div> <div>     } </div> <div>     sThreadLocal.set(new Looper());<br /> </div> <div> } </div> <div> <br /> </div> <div> Looper提供的构造器源代码如下： </div> <div> private Looper() </div> <div> { </div> <div>     mQueue=new MessageQueue();<br /> </div> <div>     mRun=true;<br /> </div> <div>     mThread=Thread.currentThread();<br /> </div> <div> } </div>

发表于 2015-08-28 20:42:30 回复(0)

Android中Looper的实现原理，为什么调用Loope

问题信息

热门推荐

相关试题