`
4ever000_1988
  • 浏览: 25052 次
  • 性别: Icon_minigender_1
  • 来自: 济南
社区版块
存档分类
最新评论

android Looper类

阅读更多

    Android中的Looper类,该类为一个线程维护一个消息队列,用于android线程中进行消息处理。消息并不是直接加入MessageQueue,而是通过与Looper对象关联MessageQueue.IdleHandler对象添加的

    调用Looper.myQueue方法可以获取当前线程的MessageQueue,MessageQueue通常附属于某一个创建它的线程

    Looper类用来为一个线程开启一个消息循环。默认情况下android中新诞生的线程是没有开启消息循环的。主线程除外,主线程系统会自动为其创建Looper对象,开启消息循环。Looper对象通过MessageQueue来存放消息和事件。一个线程只能有一个Looper,对应一个MessageQueue。 Looper对象通过MessageQueue来存放消息和事件。一个线程只能有一个Looper,对应一个MessageQueue。

    通常是通过Handler对象来与Looper进行交互的。Handler可看做是Looper的一个接口,用来向指定的Looper发送消息及定义处理方法。默认情况下Handler会与其被定义时所在线程的Looper绑定,比如,Handler在主线程中定义,那么它是与主线程的Looper绑定。mainHandler = new Handler() 等价于new Handler(Looper.myLooper()).
Looper.myLooper():获取当前进程的looper对象,类似的 Looper.getMainLooper() 用于获取主线程的Looper对象。

    在非主线程中直接new Handler() 会报如下的错误: E/AndroidRuntime( 6173): Uncaught handler: thread Thread-8 exiting due to uncaught  exception  E/AndroidRuntime( 6173): java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare() 原因是非主线程中默认没有创建Looper对象,需要先调用Looper.prepare()启用Looper。

    Looper.loop(); 让Looper开始工作,从消息队列里取消息,处理消息。

    注意:写在Looper.loop()之后的代码不会被执行,这个函数内部应该是一个循环,当调用mHandler.getLooper().quit()后,loop才会中止,其后的代码才能得以运行。

 

01.public class Looper {  
02.    private static final boolean DEBUG = false;  
03.    private static final boolean localLOGV = DEBUG ? Config.LOGD : Config.LOGV;  
04.  
05.    // sThreadLocal.get() will return null unless you've called prepare().   
06.    private static final ThreadLocal sThreadLocal = new ThreadLocal();  
07.  
08.    final MessageQueue mQueue;  
09.    volatile boolean mRun;  
10.    Thread mThread;  
11.    private Printer mLogging = null;  
12.    private static Looper mMainLooper = null;  
13.     /** Initialize the current thread as a looper. 
14.      * This gives you a chance to create handlers that then reference 
15.      * this looper, before actually starting the loop. Be sure to call 
16.      * {@link #loop()} after calling this method, and end it by calling 
17.      * {@link #quit()}. 
18.      */  
19.    public static final void prepare() {  
20.        if (sThreadLocal.get() != null) {  
21.            throw new RuntimeException("Only one Looper may be created per thread");  
22.        }  
23.        sThreadLocal.set(new Looper());  
24.}  
25./** Initialize the current thread as a looper, marking it as an application's main  
26.     *  looper. The main looper for your application is created by the Android environment, 
27.     *  so you should never need to call this function yourself. 
28.     * {@link #prepare()} 
29.     */  
30.       
31.    public static final void prepareMainLooper() {  
32.        prepare();  
33.        setMainLooper(myLooper());  
34.        if (Process.supportsProcesses()) {  
35.            myLooper().mQueue.mQuitAllowed = false;  
36.        }  
37.    }  
38.  
39.  
40.    private synchronized static void setMainLooper(Looper looper) {  
41.        mMainLooper = looper;  
42.    }  
43.      
44.    /** Returns the application's main looper, which lives in the main thread of the application. 
45.     */  
46.    public synchronized static final Looper getMainLooper() {  
47.        return mMainLooper;  
48.    }  
49.public static final void loop() {  
50.        Looper me = myLooper();  
51.        MessageQueue queue = me.mQueue;  
52.        while (true) {  
53.            Message msg = queue.next(); // might block   
54.            if (msg != null) {  
55.                if (msg.target == null) {  
56.                    return;  
57.                }  
58.                if (me.mLogging!= null) me.mLogging.println(  
59.                        ">>>>> Dispatching to " + msg.target + " "  
60.                        + msg.callback + ": " + msg.what  
61.                        );  
62.                msg.target.dispatchMessage(msg);  
63.                if (me.mLogging!= null) me.mLogging.println(  
64.                        "<<<<< Finished to    " + msg.target + " "  
65.                        + msg.callback);  
66.                msg.recycle();  
67.            }  
68.        }  
69.    }  
70./** 
71.     * Return the Looper object associated with the current thread.  Returns 
72.     * null if the calling thread is not associated with a Looper. 
73.     */  
74.    public static final Looper myLooper() {  
75.        return (Looper)sThreadLocal.get();  
76.    } 

  

分享到:
评论

相关推荐

    Android Looper使用介绍

    Android 官方文档中对 Looper 的介绍中,Looper 被描述为一个用于运行消息循环的类,线程默认情况下没有消息循环,需要调用 prepare() 方法来创建消息循环,然后调用 loop() 方法来处理消息直到循环停止。...

    android Looper

    例如,在播放音频或视频时,`MediaPlayer`类会利用`Looper`来处理来自系统服务和应用层的消息,确保播放操作的顺利进行。在处理媒体数据时,可能需要进行解码、渲染等复杂操作,这些操作通常在单独的线程中进行,...

    android Looper详解

    android looper handler 子线程 主线程详解

    Android开发中Looper.prepare()和Looper.loop()

     Looper用于封装了android线程中的消息循环,默认情况下一个线程是不存在消息循环(message loop)的,需要调用Looper.prepare()来给线程创建一个消息循环,调用Looper.loop()来使消息循环起作用,使用Looper....

    android looper分析

    Looper 类与 Handler 和 Message Queue 共同构成了 Android 的消息处理框架,它们之间的协同工作保证了应用程序能够高效地响应用户交互,并保持良好的性能表现。 #### 二、核心概念解析 **1. Looper** - **定义**...

    android Looper demo

    在Android开发中,`Looper`、`Handler`和`MessageQueue`是三个关键组件,它们共同构成了Android消息处理系统,用于实现线程间的通信,尤其是让UI线程能够响应非UI线程的数据更新。让我们深入探讨一下这些概念及其在...

    Android Handler Looper Message 使用示例

    自己写的关于Android的Looper的示例程序。在主线程即UI线程外,新建一个Looper线程,并用Messenger和Handler来处理message和posted runnable。程序中,在负线程中默认加了一个3s的线程等来,来帮助理解sent message...

    android looper

    在Android系统中,`Looper`是一个至关重要的组件,它在消息传递和事件处理机制中扮演着核心角色。本文将深入探讨`Looper`的工作原理、如何使用以及它在Android应用程序中的应用。 `Looper`是Android消息循环的核心...

    Android线程模式(handler,thread,looper)

    2. **Thread**:Thread是Java语言中的基础线程类,Android也继承了这一特性。通过创建一个新的Thread对象并调用其`start()`方法,可以启动一个新的线程。然而,Thread本身并不包含消息循环机制,所以单纯使用Thread...

    android 多线程 looper handler

    Android 多线程 Looper Handler Android 操作系统中,多线程是一种常见的编程技术,通过使用多线程,可以提高应用程序的响应速度和效率。在 Android 中,多线程可以分为两种:有消息循环的线程和没有消息循环的线程...

    Android中的Looper对象详细介绍

    在Android系统中,`Looper`类扮演着至关重要的角色,它是消息循环机制的核心。`Looper`使得线程能够处理来自`Handler`的消息,是Android异步通信和事件驱动模型的基础。下面将详细介绍`Looper`对象及其相关的主要...

    Android Handler Looper

    在Android应用开发中,Handler、Looper和Message是实现线程间通信的重要机制,尤其是在主线程与工作线程之间同步数据和执行UI更新时。Handler、Looper和Message三者结合使用,构建了一个消息处理系统,使得非UI线程...

    Android的消息处理机制--Looper,Handler

    首先,`Looper`是Android消息循环的核心。它的主要任务是不断地从`MessageQueue`中取出`Message`对象,并将其分发给相应的`Handler`进行处理。`Looper`的构造函数是私有的,目的是为了防止直接实例化,而是通过`...

    Android_Handler,Looper,Message

    在Android开发中,`Handler`、`Looper`和`Message`是实现线程间通信和异步处理的关键组件。它们共同构建了一个消息循环系统,使得应用程序可以在不同的线程之间传递和处理消息,尤其是在主线程(UI线程)与工作线程...

    android的消息处理机制(图+源码分析)——Looper,Handler,Message

    android源码中包含了...android的消息处理有三个核心类: Looper,Handler和Message。 其实还有一个Message Queue(消息队列) , 但是MQ被封装到Looper里面了, 我们不会直接与 MQ打交道, 因此我没将其作为核心类。

    Android 之 Looper、MessageQueue、Handler 与消息循环

    ### Android之Looper、MessageQueue、Handler与消息循环详解 #### 一、概述 在Android开发过程中,消息处理机制是至关重要的部分,它涉及到应用程序如何管理、传递和响应各种事件。本篇文章将深入探讨Android中...

    自定义Handler-Looper实现线程间通信

    Handler、Looper和Message是Android系统提供的一套用于在不同线程之间传递消息和进行同步的关键组件。本文将深入探讨如何自定义Handler、Looper来实现线程间的通信。 首先,我们了解下Handler的基本原理。Handler是...

    Android 线程之自定义带消息循环Looper的实例

    `Looper`是Android系统中的一个类,它负责在一个线程中循环地读取并分发消息。在Android的主线程(UI线程)中,有一个默认的`Looper`,使得我们可以使用`Handler`来处理异步消息,从而更新UI或者执行其他任务。当...

    android 之 Hnadler 、Message 、Looper

    在Android应用开发中,Handler、Message和Looper是用于线程间通信的重要组件,尤其是在处理UI更新和异步任务时。理解它们的工作原理是成为一名专业Android开发者的关键。 首先,我们来看`Handler`。Handler是一个...

Global site tag (gtag.js) - Google Analytics