Android中的Handler详解以及和Thread的区别

Posted 2023-05-05

一、Handler的定义:
主要接受子线程发送的数据, 并用此数据配合主线程更新UI.

解释: 当应用程序启动时，android首先会开启一个主线程 (也就是UI线程) , 主线程为管理界面中的UI控件，进行事件分发, 比如说, 你要是点击一个 Button ,Android会分发事件到Button上，来响应你的操作。 如果此时需要一个耗时的操作，例如: 联网读取数据， 或者读取本地较大的一个文件的时候，你不能把这些操作放在主线程中，，如果你放在主线程中的话，界面会出现假死现象, 如果5秒钟还没有完成的话，，会收到Android系统的一个错误提示 "强制关闭". 这个时候我们需要把这些耗时的操作，放在一个子线程中,因为子线程涉及到UI更新，，Android主线程是线程不安全的，也就是说，更新UI只能在主线程中更新，子线程中操作是危险的. 这个时候，Handler就出现了.,来解决这个复杂的问题 , 由于Handler运行在主线程中(UI线程中), 它与子线程可以通过Message对象来传递数据, 这个时候，Handler就承担着接受子线程传过来的(子线程用sedMessage()方法传弟)Message对象，(里面包含数据) , 把这些消息放入主线程队列中，配合主线程进行更新UI。

二、Handler一些特点

handler可以分发Message对象和Runnable对象到主线程中, 每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程),
它有两个作用: (1): 安排消息或Runnable 在某个主线程中某个地方执行, (2)安排一个动作在不同的线程中执行

Handler中分发消息的一些方法

[html] view plain copy
post(Runnable)
postAtTime(Runnable,long)
postDelayed(Runnable long)
sendEmptyMessage(int)
sendMessage(Message)
sendMessageAtTime(Message,long)
sendMessageDelayed(Message,long)

以上post类方法允许你排列一个Runnable对象到主线程队列中,
sendMessage类方法, 允许你安排一个带数据的Message对象到队列中，等待更新.

三、Handler实例

(1) 子类需要继承Hendler类，并重写handleMessage(Message msg) 方法, 用于接受线程数据

以下为一个实例，它实现的功能为 : 通过线程修改界面Button的内容

[html] view plain copy
public class MyHandlerActivity extends Activity

Button button;

MyHandler myHandler;

protected void onCreate(Bundle savedInstanceState)

super.onCreate(savedInstanceState);

setContentView(R.layout.handlertest);

button = (Button) findViewById(R.id.button);

myHandler = new MyHandler();

// 当创建一个新的Handler实例时, 它会绑定到当前线程和消息的队列中,开始分发数据

// Handler有两个作用, (1) : 定时执行Message和Runnalbe 对象

// (2): 让一个动作,在不同的线程中执行.

// 它安排消息,用以下方法

// post(Runnable)

// postAtTime(Runnable,long)

// postDelayed(Runnable,long)

// sendEmptyMessage(int)

// sendMessage(Message);

// sendMessageAtTime(Message,long)

// sendMessageDelayed(Message,long)

// 以上方法以 post开头的允许你处理Runnable对象

//sendMessage()允许你处理Message对象(Message里可以包含数据,)

MyThread m = new MyThread();

new Thread(m).start();



/**

* 接受消息,处理消息 ,此Handler会与当前主线程一块运行

* */

class MyHandler extends Handler

public MyHandler()



public MyHandler(Looper L)

super(L);



// 子类必须重写此方法,接受数据

@Override

public void handleMessage(Message msg)

// TODO Auto-generated method stub

Log.d("MyHandler", "handleMessage......");

super.handleMessage(msg);

// 此处可以更新UI

Bundle b = msg.getData();

String color = b.getString("color");

MyHandlerActivity.this.button.append(color);





class MyThread implements Runnable

public void run()

try

Thread.sleep(10000);

catch (InterruptedException e)

// TODO Auto-generated catch block

e.printStackTrace();



Log.d("thread.......", "mThread........");

Message msg = new Message();

Bundle b = new Bundle();// 存放数据

b.putString("color", "我的");

msg.setData(b);

MyHandlerActivity.this.myHandler.sendMessage(msg); // 向Handler发送消息,更新UI







例外一个案例：

[html] view plain copy
package com.example.span.view;

import java.util.LinkedList;
import android.app.AlertDialog;
import android.content.ComponentName;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Point;
import android.graphics.RectF;
import android.os.Handler;
import android.os.Message;
import android.util.AttributeSet;
import android.view.KeyEvent;
import android.view.View;
import android.widget.Toast;

import com.example.span.view.domain.Block;

/**
* 2013-6-6 上午9:24:58
*
* @author 乔晓松
*/
public class GameView extends View

public static boolean flag = true;
public static Block block;
public Handler handler;
public static int dir = 2;
public static final int DIRTOP = -1;
public static final int DIRLEFT = -2;
public static final int DIRDOWN = 1;
public static final int DIRRIGHT = 2;
public static int descount = 2;
public Canvas canvas;
public static Food food;
public LinkedList<Point> points = new LinkedList<Point>();

public LinkedList<Point> getPoints()
return points;


public void setPoints(LinkedList<Point> points)
this.points = points;


public GameView(Context context, AttributeSet attrs)
super(context, attrs);
block = new Block(this);
for (int i = 0; i < 3; i++)
Point point = new Point(block.getCx(), block.getCy());
block.setCx(block.getCx() - 20);
points.addLast(point);

food = new Food(this);
handler = new Handler()

@Override
public void handleMessage(Message msg)
super.handleMessage(msg);
switch (msg.what)
case DIRLEFT:
if (msg.what + descount != 0)
descount = -2;
block.moveLeft();
else
block.moveRight();

break;
case DIRRIGHT:
if (msg.what + descount != 0)
descount = 2;
block.moveRight();
else
block.moveLeft();

break;
case DIRTOP:
if (msg.what + descount != 0)
descount = -1;
block.giveUp();
else
block.downLoad();

break;
case DIRDOWN:
if (msg.what + descount != 0)
descount = 1;
block.downLoad();
else
block.giveUp();

break;
case -3:
Toast.makeText(getContext(), "Game Over", Toast.LENGTH_LONG)
.show();
new AlertDialog.Builder(getContext())
.setTitle("游戏提示")
.setMessage("Game Over")
.setPositiveButton("退出",
new DialogInterface.OnClickListener()

@Override
public void onClick(
DialogInterface dialog,
int which)
Thread.currentThread().stop();

)
.setNegativeButton("返回菜单",
new DialogInterface.OnClickListener()

@Override
public void onClick(
DialogInterface dialog,
int which)

Intent intent = new Intent();
intent.setAction("android.intent.action.MAI");
intent.addCategory("android.intent.category.LAUNCHER");
intent.setFlags(0x10200000);
intent.setComponent(new ComponentName(
"com.example.span",
"com.example.span.SpanActivity"));
getContext().startActivity(intent);


).show();
break;


;
new Thread(new Runnable()

@Override
public void run()
while (flag)
try
Thread.sleep(500);
handler.sendEmptyMessage(dir);
catch (InterruptedException e)
e.printStackTrace();


handler.sendEmptyMessage(-3);

).start();


@Override
public boolean onKeyDown(int keyCode, KeyEvent event)
System.out.println(keyCode);
return super.onKeyDown(keyCode, event);


@Override
protected void onDraw(Canvas canvas)
super.onDraw(canvas);
this.canvas = canvas;
food.chsw(canvas);
/*
* if (descount == 2) chsw(); else if (points.contains(new
* Point(40, 40))) System.out.println("吃掉食物了,,.."); else chsw();
* 参考技术A 一、Handler的定义:
主要接受子线程发送的数据, 并用此数据配合主线程更新UI.
解释: 当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程) , 主线程为管理界面中的UI控件，进行事件分发, 比如说, 你要是点击一个 Button ,Android会分发事件到Button上，来响应你的操作。 如果此时需要一个耗时的操作，例如: 联网读取数据， 或者读取本地较大的一个文件的时候，你不能把这些操作放在主线程中，，如果你放在主线程中的话，界面会出现假死现象, 如果5秒钟还没有完成的话，，会收到Android系统的一个错误提示 "强制关闭". 这个时候我们需要把这些耗时的操作，放在一个子线程中,因为子线程涉及到UI更新，，Android主线程是线程不安全的，也就是说，更新UI只能在主线程中更新，子线程中操作是危险的. 这个时候，Handler就出现了.,来解决这个复杂的问题 , 由于Handler运行在主线程中(UI线程中), 它与子线程可以通过Message对象来传递数据, 这个时候，Handler就承担着接受子线程传过来的(子线程用sedMessage()方法传弟)Message对象，(里面包含数据) , 把这些消息放入主线程队列中，配合主线程进行更新UI。
二、Handler一些特点
handler可以分发Message对象和Runnable对象到主线程中, 每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程),
它有两个作用: (1): 安排消息或Runnable 在某个主线程中某个地方执行, (2)安排一个动作在不同的线程中执行
Handler中分发消息的一些方法
post(Runnable)
postAtTime(Runnable,long)
postDelayed(Runnable long)
sendEmptyMessage(int)
sendMessage(Message)
sendMessageAtTime(Message,long)
sendMessageDelayed(Message,long)
以上post类方法允许你排列一个Runnable对象到主线程队列中,
sendMessage类方法, 允许你安排一个带数据的Message对象到队列中，等待更新.
三、Handler实例
(1) 子类需要继承Hendler类，并重写handleMessage(Message msg) 方法, 用于接受线程数据
以下为一个实例，它实现的功能为 : 通过线程修改界面Button的内容
public class MyHandlerActivity extends Activity
Button button;
MyHandler myHandler;

protected void onCreate(Bundle savedInstanceState)
super.onCreate(savedInstanceState);
setContentView(R.layout.handlertest);

button = (Button) findViewById(R.id.button);
myHandler = new MyHandler();
// 当创建一个新的Handler实例时, 它会绑定到当前线程和消息的队列中,开始分发数据
// Handler有两个作用, (1) : 定时执行Message和Runnalbe 对象
// (2): 让一个动作,在不同的线程中执行.

// 它安排消息,用以下方法
// post(Runnable)
// postAtTime(Runnable,long)
// postDelayed(Runnable,long)
// sendEmptyMessage(int)
// sendMessage(Message);
// sendMessageAtTime(Message,long)
// sendMessageDelayed(Message,long)

// 以上方法以 post开头的允许你处理Runnable对象
//sendMessage()允许你处理Message对象(Message里可以包含数据,)

MyThread m = new MyThread();
new Thread(m).start();


/**
* 接受消息,处理消息 ,此Handler会与当前主线程一块运行
* */

class MyHandler extends Handler
public MyHandler()


public MyHandler(Looper L)
super(L);


// 子类必须重写此方法,接受数据
@Override
public void handleMessage(Message msg)
// TODO Auto-generated method stub
Log.d("MyHandler", "handleMessage......");
super.handleMessage(msg);
// 此处可以更新UI
Bundle b = msg.getData();
String color = b.getString("color");
MyHandlerActivity.this.button.append(color);




class MyThread implements Runnable
public void run()

try
Thread.sleep(10000);
catch (InterruptedException e)
// TODO Auto-generated catch block
e.printStackTrace();


Log.d("thread.......", "mThread........");
Message msg = new Message();
Bundle b = new Bundle();// 存放数据
b.putString("color", "我的");
msg.setData(b);

MyHandlerActivity.this.myHandler.sendMessage(msg); // 向Handler发送消息,更新UI




本回答被提问者和网友采纳 参考技术B Handler是主线程，Thread一般用来开启子线程，ui的操作必须在主线程里面，请求网络的要放到子线程里面。 参考技术C

andriod提供了Handler 和 Looper 来满足线程间的通信。Handler先进先出原则。Looper类用来管理特定线程内对象之间的消息交换(MessageExchange)。

Looper: 一个线程可以产生一个Looper对象，由它来管理此线程里的MessageQueue(消息队列)。 
Handler: 你可以构造Handler对象来与Looper沟通，以便push新消息到MessageQueue里;或者接收Looper从Message Queue取出)所送来的消息。
Message Queue(消息队列):用来存放线程放入的消息。 

线程：UIthread 通常就是main thread，而Android启动程序时会替它建立一个MessageQueue。 

1.Handler创建消息

        每一个消息都需要被指定的Handler处理，通过Handler创建消息便可以完成此功能。Android消息机制中引入了消息池。Handler创建消息时首先查询消息池中是否有消息存在，如果有直接从消息池中取得，如果没有则重新初始化一个消息实例。使用消息池的好处是：消息不被使用时，并不作为垃圾回收，而是放入消息池，可供下次Handler创建消息时使用。消息池提高了消息对象的复用，减少系统垃圾回收的次数。消息的创建流程如图所示。

2.Handler发送消息

UI主线程初始化第一个Handler时会通过ThreadLocal创建一个Looper，该Looper与UI主线程一一对应。使用ThreadLocal的目的是保证每一个线程只创建唯一一个Looper。之后其他Handler初始化的时候直接获取第一个Handler创建的Looper。Looper初始化的时候会创建一个消息队列MessageQueue。至此，主线程、消息循环、消息队列之间的关系是1:1:1。

Handler、Looper、MessageQueue的初始化流程如图所示:

Hander持有对UI主线程消息队列MessageQueue和消息循环Looper的引用，子线程可以通过Handler将消息发送到UI线程的消息队列MessageQueue中。

3.Handler处理消息

UI主线程通过Looper循环查询消息队列UI_MQ，当发现有消息存在时会将消息从消息队列中取出。首先分析消息，通过消息的参数判断该消息对应的Handler，然后将消息分发到指定的Handler进行处理。

子线程通过Handler、Looper与UI主线程通信的流程如图所示。

Android Handler机制

• 《Android Handler机制》
• 《Android Handler分析（一） Handler和Message详解》
• 《Android Handler分析 (二) MessageQueue详解》
• 《Android Handler分析 (三) Looper详解和Handler其他知识》
• 《Android 中的 HandlerThread 类详解》

作为一个Android程序员，我想大家都知道在做一些比较耗时的操作的时候都不会放在主线程，比如网络请求、数据库操作等(尤其是网络请求，在Android4.0之后强制不能放在主线程中执行，否则抛出android.os.NetworkOnMainThreadException异常)，而更新UI的操作的都是由UI线程处理。那么有这样一个需求，我在一个新的线程中获取到数据，然后设置到界面上，这就涉及到了两个线程，用于更新界面的UI线程不知道什么时候数据获取完成可以更新界面了，那怎么办呢？Google就给我们提供了一个解决方案，也就是我们今天主要说明的内容——Android中的Handler消息机制。

首先来一个简单使用：

private static final int HANDLER_TEST_WHAT = 0x01; // 定义测试what

// 创建Handler对象，并重写handleMessage()方法处理消息
private Handler handler = new Handler()
	@Override
	public void handleMessage(Message msg) 
	    int what = msg.what; // 获取消息的what
	    // 通过what对消息进行判断，不同消息不同的处理
	    if(what == HANDLER_TEST_WHAT)
		// 处理消息
	    
	
;

// 创建一个子线程发送消息
new Thread()
    @Override
    public void run() 
	Message message = Message.obtain(); // 创建一个消息对象，使用obtain()重用回收的消息对象
	message.what = HANDLER_TEST_WHAT;   // 设置Message的 what
	handler.sendMessage(message);       // 发送一个消息
    
.start();

上面就是一个简单的例子，在子线程发送一个消息，然后在主线程就可以对消息进行处理，当然包括更新UI或者其他操作。

下面我们就从源码的角度查看与分析一下Handler消息机制，他是怎样将一个子线程的数据传递到主线程中的。

介绍Handler机制之前，首先了解几个概念：

• **Message：**消息，理解为线程间通讯的数据单元。例如后台线程在处理数据完毕后需要更新UI，则可发送一条包含更新信息的Message给UI线程。
• **MessageQueue：**消息队列，用来存放通过Handler发布的消息并按时间进行排序，按照先进先出执行。
• **Handler：**Handler是Message的主要处理者，负责将Message添加到消息队列以及对消息队列中的Message进行处理。
• **Looper：**轮询器，扮演MessageQueue和Handler之间桥梁的角色，循环取出MessageQueue里面的Message，并交付给相应的Handler进行处理。

消息机制分析

从上面的示例中，我们先创建了一个Handler对象并且重写了 handleMessage() 方法用来处理接收到的消息，而消息的发送是通过 Handler 的sendMessage() 方法。也可以说，Handler机制是由 sendMessage() 方法开始，到 handleMessage() 方法结束，现在我们就来一步一步看看数据是怎样传递的，线程又是怎样切换的。

首先看看创建 Handler

最终调用的是 带两个参数 的构造方法，如下：

	public Handler(@Nullable Callback callback, boolean async) 
        
        mLooper = Looper.myLooper();
        if (mLooper == null) 
            throw new RuntimeException(
                "Can't create handler inside thread " + Thread.currentThread()
                        + " that has not called Looper.prepare()");
        
        mQueue = mLooper.mQueue;
    

说明：

1. Looper.myLooper()：获取当前线程的 Looper 对象，也就是线程需要是一个 Looper 线程，主线程就是一个 Looper 线程，主线程为什么是一个Looper线程以及怎样将一个线程变为 Looper 线程，在《Android Handler分析 (三) Looper详解和Handler其他知识》中有说到。

    public static @Nullable Looper myLooper() 
        return sThreadLocal.get();
    
   

2. mLooper.mQueue：就是一个 MessageQueue 对象，他是在 Looper 构造方法中初始化的

    private Looper(boolean quitAllowed) 
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    
   

我们创建了 Handler 对象之后，然后通过 Handler 的 sendMessage() 方法发送一个 Message，接下来看看 sendMessage() 方法做了写什么事

Handler#sendMessage() 方法

	public final boolean sendMessage(@NonNull Message msg) 
        return sendMessageDelayed(msg, 0);
    

	public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) 
        if (delayMillis < 0) 
            delayMillis = 0;
        
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    

	public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) 
        MessageQueue queue = mQueue;
        if (queue == null) 
            RuntimeException e = new RuntimeException(
                    this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
            return false;
        
        return enqueueMessage(queue, msg, uptimeMillis);
    

	private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg, long uptimeMillis) 
		// 注意这行代码，将 Message 的 target 变量赋值成 this，也就是当前 Handler 对象
        msg.target = this;
        msg.workSourceUid = ThreadLocalWorkSource.getUid();

        if (mAsynchronous) 
            msg.setAsynchronous(true);
        
        return queue.enqueueMessage(msg, uptimeMillis);
    

说明：

1. sendMessage() 方法调用了一些 Message 类自身的发送方法，主要是处理消息发送时间（立马发送还是延迟发送等）
2. 最终调用 enqueueMessage() 方法，在这个方法中又调用了 queue.enqueueMessage(msg, uptimeMillis) ，queue 就是 MessageQueue，所以查看一下 MessageQueue 中的 enqueueMessage() 方法
3. 重点注意enqueueMessage() 方法中的 msg.target = this 代码，将 Message 的 target 变量赋值成 this，也就是当前 Handler对象

MessageQueue#enqueueMessage() 方法

boolean enqueueMessage(Message msg, long when) 
    if (msg.target == null) 
        throw new IllegalArgumentException("Message must have a target.");
    
    if (msg.isInUse()) 
        throw new IllegalStateException(msg + " This message is already in use.");
    

    synchronized (this) 
        if (mQuitting) 
            IllegalStateException e = new IllegalStateException(
                    msg.target + " sending message to a Handler on a dead thread");
            Log.w(TAG, e.getMessage(), e);
            msg.recycle();
            return false;
        

        msg.markInUse();
        msg.when = when;
        Message p = mMessages;
        boolean needWake;
        if (p == null || when == 0 || when < p.when) 
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;
         else 
            Message prev;
            for (;;) 
                prev = p;
                p = p.next;
                if (p == null || when < p.when) 
                    break;
                
                if (needWake && p.isAsynchronous()) 
                    needWake = false;
                
            
            msg.next = p; // invariant: p == prev.next
            prev.next = msg;
        

        // We can assume mPtr != 0 because mQuitting is false.
        if (needWake) 
            nativeWake(mPtr);
        
    
    return true;

这个方法所做的事情就是将 Message 对象根据发送时间添加到队列中，方法的具体分析在 《Android Handler分析 (二) MessageQueue详解》中。

Message 消息对象添加到 MessageQueue 中之后，在哪里取出来，并且传递到 handleMessage() 方法呢？

这里我们就有必要先说一下 Looper 线程了，一个类变为Looper线程并且能处理消息，主要有两步：

1. 调用 Looper.prepare() 方法
2. 调用 Looper.loop() 方法开始轮询

至于这两个方法具内容是什么我们这里就不说了，在《Android Handler分析 (三) Looper详解和Handler其他知识》中有分析，只需要知道 loop() 方法最重要的作用就是不断的循环调用 MessageQueue 的 next() 方法去获取 Message ，然后进行处理，而 MessageQueue 的 next() 方法的消息分析在 《Android Handler分析 (二) MessageQueue详解》中，它的主要作用就是按照顺序从队列里面取出 Message。

所以我们直接看 MessageQueue.next() 取到消息之后 Looper.loop() 方法是怎样处理的，核心代码如下：

public static void loop() 
	final Looper me = myLooper();
	final MessageQueue queue = me.mQueue;
	Message msg = queue.next();
	try 
        msg.target.dispatchMessage(msg);
     catch (Exception exception) 
     finally 
    

说明：

通过获取的 Message 对象的变量 target, 调用它的 dispatchMessage() 方法，并且将 msg 对象传递给 dispatchMessage() 方法。在上面，我们已经知道了 target 变量表示的就是 Handler，所以这里调用的就是 Handler 的 dispatchMessage() 方法了。

Handler#dispatchMessage() 方法

public void dispatchMessage(@NonNull Message msg) 
    if (msg.callback != null) 
        handleCallback(msg);
     else 
        if (mCallback != null) 
            if (mCallback.handleMessage(msg)) 
                return;
            
        
        handleMessage(msg);
    

在 dispatchMessage() 方法中调用了 handleMessage(msg) 方法并传递 Message，这个方法我们在创建 Handler 时重写了。所以就走到了我们自己处理消息的部分。因为我们的这个Handler是在主线程创建的并且绑定的也是主线程的Looper，所以这个方法就在主线程当中执行了。