Android消息机制Handler解析（源码+Demo）

最新推荐文章于 2024-05-02 20:43:14 发布
最新推荐文章于 2024-05-02 20:43:14 发布
阅读量600 收藏 1
点赞数 1
分类专栏： Android 文章标签： Android Handler
原文链接：https://blog.csdn.net/chen_lian_/article/details/51031331
版权

转载自： https://blog.csdn.net/chen_lian_/article/details/51031331


Handler是开发人员在面试过程中最常见的问题之一了，这篇文章将较为全面地对Handler进行解读，包括源码层，以及使用方法。

如果看完文章有疑问，欢迎在评论中一起探讨

基本内容包括：


看完文章之后，可以用这个图片进行复习。


一、什么是Handler
Handler是Android提供用来更新UI的一套机制，也是一套消息处理机制，可以用它来发送消息，也可以用它来接收消息。

二、为什么使用Handler
Android在设计之时，就封装了一套消息的创建、传递、处理机制，若不遵循这样的处理机制，就没办法更新UI信息，并且会抛出异常

三、Handler用法
1、postdelayed（）延时发送执行子线程

文字轮询Demo（实现每隔一秒钟更新一次Textview的功能） 
public class MainActivity extends AppCompatActivity {  
  
  
    private TextView mTextView;  
  
    private Handler mHandler = new Handler(){  
        @Override  
        public void handleMessage(Message msg) {  
            super.handleMessage(msg);  
        }  
    };  
  
    private String[] str = new String[]{"傲慢","偏见","僵尸"};  
    private int index = 0;  
    MyRunnable myRunnable = new MyRunnable();
  
    private class MyRunnable implements Runnable{  
  
        @Override  
        public void run() {  
            index = index % 3;  
            mTextView.setText(str[index]);  
            index ++;  
            mHandler.postDelayed(myRunnable,1000);  
        }  
    }  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
  
        mTextView = (TextView) findViewById(R.id.tv);  
  
  
        mHandler.postDelayed(myRunnable,1000);  
    }  
}

2、sendMessage（）回调handleMessage（）传递消息

     Demo：在子线程中得到信息，发送至主线程，更新textview的内容 

public class MainActivity extends AppCompatActivity {  
  
  
    private TextView mTextView;  
  
    Handler mHandler = new Handler(){  
        @Override  
        public void handleMessage(Message msg) {
	        Person p = (Person)msg.obj;  
            mTextView.setText(p.toString() + "arg1="+msg.arg1 + " arg2=" + msg.arg2);  
            super.handleMessage(msg);  
        }  
    };  
  
    private  class Person{  
        String name;  
        int age;  
  
        @Override  
        public String toString() {  
            return "name="+name+" age="+age;  
        }  
    }  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
  
        mTextView = (TextView) findViewById(R.id.tv);  
  
        new Thread(){  
            @Override  
            public void run() {  
                Message msg = new Message();  
                msg.arg1 = 1;  
                msg.arg2 = 2;  
                Person person = new Person();  
                person.name = "pig";  
                person.age = 10;  
                msg.obj = person;  
                mHandler.sendMessage(msg);  
            }  
        }.start();  
  
    }  
}

3、sendToTarget（）传递消息
     与第二种用法原理一致 
public class MainActivity extends AppCompatActivity {  
  
  
    private TextView mTextView;  
  
    Handler mHandler = new Handler(){  
        @Override  
        public void handleMessage(Message msg) {
	        Person p = (Person)msg.obj;  
            mTextView.setText(p.toString()+ "arg1="+msg.arg1 + " arg2="+msg.arg2);  
            super.handleMessage(msg);  
        }  
    };  
  
    private  class Person{  
        String name;  
        int age;  
  
        @Override  
        public String toString() {  
            return "name="+name+" age="+age;  
        }  
    }  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
  
        mTextView = (TextView) findViewById(R.id.tv);  
  
        new Thread(){  
            @Override  
            public void run() {  
                Message msg = mHandler.obtainMessage();//同样可以获取Message对象  
                msg.arg1 = 1;  
                msg.arg2 = 2;  
                Person person = new Person();  
                person.name = "pig";  
                person.age = 10;  
                msg.obj = person;  
                msg.sendToTarget();  
            }  
        }.start();  
  
    }  
}

4、使用CallBack截获Handler的消息

public class MainActivity extends AppCompatActivity {  
  
  
    private TextView mTextView;  
  
	Handler mHandler = new Handler(new Handler.Callback() {  
	    //传入CallBack对象，对于重载的返回值为bollean的handleMessage（）  
	    //返回值为false，将先执行这个方法，再执行返回值为void的handleMessage（）方法  
	    //返回值为true,只执行这个方法  
	    @Override  
	    public boolean handleMessage(Message msg) {  
	        Toast.makeText(MainActivity.this, "截获消息", Toast.LENGTH_SHORT).show();  
	        return false;  
	    }  
	}){  
	    public void handleMessage(Message msg) {  
	        Toast.makeText(MainActivity.this, "发出消息", Toast.LENGTH_SHORT).show();  
		}  
	};  
  
    private  class Person{  
        String name;  
        int age;  
  
        @Override  
        public String toString() {  
            return "name="+name+" age="+age;  
        }  
    }  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
  
        mTextView = (TextView) findViewById(R.id.tv);  
        Button btn = (Button) findViewById(R.id.btn);  
        btn.setOnClickListener(new View.OnClickListener() {  
            @Override  
            public void onClick(View v) {  
                mHandler.sendEmptyMessage(0);  
            }  
        });  
  
  
    }  
}
四、为什么在Android中智能通过Handler机制在主线程中更新UI？

最根本的是 解决多线程并发问题。
假如在同一个Activity中，有多个线程同时更新UI，且没有加锁，那会导致什么问题呢？
UI更新混乱。
假如加锁呢？
会导致 性能下降。
使用Handler机制，我们不用去考虑多线程的问题，所有更新UI的操作，都是在 主线程消息队列中轮询去处理的。

五、Handler机制的原理

1、Handler封装了消息的发送（主要包括消息发送给谁）
Looper
（1）内部包含一个消息队列，即MessageQueue，所有Handler发送的消息都会进入这个队列
（2）Looper.loop方法，是一个死循环，不断从MessageQueue取出消息，如有消息就处理，没有就阻塞

2、MessageQueue，一个消息队列，可以添加消息，处理消息

3、Handler内部会跟Looper进行关联，也就是说，在Handler内部可以找到Looper，找到了Looper也就找到了MessageQueue，在Handler中发送消息，其实就是向MessageQueue发送消息，

总结：Handler负责发送消息，Looper负责接收消息，并把消息回传给Handler自己，而MessageQueue是一个存储消息的容器。


源码层：
Android的应用程序是通过ActivityThread进行创建，在ActivityThread默认创建一个Main线程，一个Looper，所有更新UI的线程都是通过Main线程进行创建的。
查看Looper.loop的源代码，发现确实是一个死循环 

public static void loop() {  
    final Looper me = myLooper();  
    if (me == null) {  
        throw new RuntimeException("No Looper; Looper.prepare() wasn’t called on this thread.");  
    }  
    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  
        Printer logging = me.mLogging;  
        if (logging != null) {  
            logging.println(">>>>> Dispatching to " + msg.target + " " +  
                    msg.callback + ": " + msg.what);  
        }  
  
        msg.target.dispatchMessage(msg);  
  
        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);  
        }  
  
        msg.recycleUnchecked();  
    }  
}

发现是通过msg.target.dispatchMessage()方法来处理消息，查看其源码


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

从源码看出，当有CallBack的时候，会截获消息，没有的话会回调handleMessage（）来处理消息

而对于SendMessage（）系列的方法，这里不再做过多解析，但从其源码可以看出，确实是最终把消息传入了消息队列中。

六、创建与线程相关的Handler


在子线程中创建Handler，需要通过Looper.prepare()获取Looper，且调用Looper.loop()方法对消息队列中的Message进行轮询 

public class MainActivity extends AppCompatActivity {  
  
  
    private TextView mTextView;  
  
    public Handler mHandler = new Handler(){//主线程中的Handler  
        @Override  
        public void handleMessage(Message msg) {  
            Log.d("CurrentThread",Thread.currentThread()+"");//打印Thread 的ID  
        }  
    };  
  
    class MyThread extends Thread{  
        private Handler handler;//子线程中的Handler  
        @Override  
        public void run() {  
            Looper.prepare();//获取Looper  
            handler = new Handler(){  
                @Override  
                public void handleMessage(Message msg) {  
                    Log.d("CurrentThread",Thread.currentThread()+"");  
                }  
            };  
            Looper.loop();//轮询消息队列  
        }  
    }  
  
  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
  
        MyThread thread= new MyThread();  
        thread.start();  
        try {  
            thread.sleep(500);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        thread.handler.sendEmptyMessage(1);  
        mHandler.sendEmptyMessage(1);  
    }  
}

输出的结果 
03-31 20:56:06.498 1804-1816/? D/CurrentThread: Thread[Thread-113,5,main]
03-31 20:56:06.578 1804-1804/com.lian.handlerdemo D/CurrentThread: Thread[main,5,main]

七、HandlerThread

HandlerThread本质是一个Thread，区别在于他在run（）之后创建了一个含有消息队列的Looper，这样我们在子线程中创建Handler时候只需指定使用HandlerThread中的Looper，不用再调用Looper.prepare(),looper.loop()等，简化了操作。
Android系统提供的Handler使用的Looper默认绑定了UI线程的消息队列，所以我们在Handler中不能进行耗时操作，而对于非UI线程，若想使用消息机制，HandlerThread内部的Looper是最合适的，他不会阻塞UI线程。 

public class MainActivity extends AppCompatActivity {  
  
  
    private TextView mTextView;  
  
    public HandlerThread mHandlerThread;  
  
  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
  
        mHandlerThread = new HandlerThread("handler thread");  
        mHandlerThread.start();  
        Handler handler = new Handler(mHandlerThread.getLooper()){//通过getLooper（）获取Looper  
            @Override  
            public void handleMessage(Message msg) {  
                Log.d("current thread","" + Thread.currentThread());  
            }  
        };  
        handler.sendEmptyMessage(1);  
    }  
}
结果： 
03-31 21:36:42.770 7225-7237/? D/current thread: Thread[handler thread,5,main]

八、主线程与子线程信息交互

主线程中的Handler与子线程中的Handler互相发送消息，只要调用对方的sendMessage（）就可以了 

public class MainActivity extends AppCompatActivity {  
  
  
    public Handler mHandler = new Handler(){  
        @Override  
        public void handleMessage(Message msg) {  
            Log.d("current thread", "" + Thread.currentThread());  
            Message message = new Message();  
            message.what = 1;  
            handler.sendMessageDelayed(message,1000);//向子线程的Handler发送消息  
        }  
    };  
  
    public HandlerThread mHandlerThread;  
    public Handler handler;  
    private Button btn1,btn2;  
  
  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
  
        btn1 = (Button) findViewById(R.id.btn);  
        btn2 = (Button) findViewById(R.id.btn2);  
  
        mHandlerThread = new HandlerThread("handler thread");//指定HandlerThread的名字  
        mHandlerThread.start();  
        handler = new Handler(mHandlerThread.getLooper()){//通过getLooper（）获取Looper  
            @Override  
            public void handleMessage(Message msg) {  
                Log.d("current thread", "" + Thread.currentThread());  
                Message message = new Message();  
                mHandler.sendMessageDelayed(message,1000);//向主线程中的Handler发送消息  
            }  
        };  
  
        btn1.setOnClickListener(new View.OnClickListener() {  
            @Override  
            public void onClick(View v) {  
                handler.sendEmptyMessage(1);//开始发送消息  
            }  
        });  
  
        btn2.setOnClickListener(new View.OnClickListener() {  
            @Override  
            public void onClick(View v) {  
                handler.removeMessages(1);//停止发送消息  
            }  
        });  
  
    }  
}

结果： 
03-31 22:21:11.422 16748-16760/com.lian.handlerdemo D/current thread: Thread[handler thread,5,main]
03-31 22:21:12.422 16748-16748/com.lian.handlerdemo D/current thread: Thread[main,5,main]
03-31 22:21:13.422 16748-16760/com.lian.handlerdemo D/current thread: Thread[handler thread,5,main]
03-31 22:21:14.422 16748-16748/com.lian.handlerdemo D/current thread: Thread[main,5,main]
03-31 22:21:15.426 16748-16760/com.lian.handlerdemo D/current thread: Thread[handler thread,5,main]
03-31 22:21:16.426 16748-16748/com.lian.handlerdemo D/current thread: Thread[main,5,main]
03-31 22:21:20.414 16748-16760/com.lian.handlerdemo D/current thread: Thread[handler thread,5,main]
03-31 22:21:21.414 16748-16748/com.lian.handlerdemo D/current thread: Thread[main,5,main]
03-31 22:21:22.414 16748-16760/com.lian.handlerdemo D/current thread: Thread[handler thread,5,main]
03-31 22:21:23.418 16748-16748/com.lian.handlerdemo D/current thread: Thread[main,5,main]

九、四种更新UI的方法

1、Handler.post();

2、Handler.sendMessage();
第一二种方法事实上没有本质的区别，都是通过发送消息，在UI线程中更新UI，前面已经做过演示，不再赘述

3、runOnUIThread()
使用方法： 
public class MainActivity extends AppCompatActivity {  
    TextView mTextView;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
  
        mTextView = (TextView) findViewById(R.id.tv);  
  
        new Thread(){  
  
            @Override  
            public void run() {  
  
                try {  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
                runOnUiThread(new Runnable() {  
                    @Override  
                    public void run() {  
                        mTextView.setText("更新UI");  
                    }  
                });  
            }  
        }.start();  
  
    }  
}

我们查看runOnUIThread()的源代码 

public final void runOnUiThread(Runnable action) {  
    if (Thread.currentThread() != mUiThread) {  
        mHandler.post(action);  
    } else {  
        action.run();  
    }  
}


可以发现，其本质上仍然是通过Handler.post()方法再UI线程中更新UI


4、View.post()

使用方法:

public class MainActivity extends AppCompatActivity {  
    TextView mTextView;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
  
        mTextView = (TextView) findViewById(R.id.tv);  
  
        new Thread(){  
            @Override  
            public void run() {  
                try {  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
                mTextView.post(new Runnable() {  
                    @Override  
                    public void run() {  
                        mTextView.setText("更新UI");  
                    }  
                });  
            }  
        }.start();  
  
    }  
}

查看其源码，一样是采用Handler.post()方法更新UI 

public boolean post(Runnable action) {  
    final AttachInfo attachInfo = mAttachInfo;  
    if (attachInfo != null) {  
        return attachInfo.mHandler.post(action);  
    }  
    // Assume that post will succeed later  
    ViewRootImpl.getRunQueue().post(action);  
    return true;  
}

十、在非UI线程中更新UI的方法

 先看一个Demo 
public class MainActivity extends AppCompatActivity {  
    TextView mTextView;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
  
        mTextView = (TextView) findViewById(R.id.tv);  
  
        new Thread(){  
            @Override  
            public void run() {  
                mTextView.setText("更新UI了");  
            }  
        }.start();  
  
    }  
}

结果：



惊讶地发现，成功更新了UI，并没有抛出异常

然而当我们先让线程休眠2s，再更新 

public class MainActivity extends AppCompatActivity {  
    TextView mTextView;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
  
        mTextView = (TextView) findViewById(R.id.tv);  
  
        new Thread(){  
            @Override  
            public void run() {  
  
                try {  
                    Thread.sleep(2000);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
  
                mTextView.setText("更新UI了");  
            }  
        }.start();  
  
    }  
}

更新失败，抛出异常


这是什么原因呢？

在Activity中有一个ViewRootImpl类，这个类没有实例化的时候，系统不会检测当前线程是否UI线程，而这个类的实例化是在Activity的onResume（）中实现，所以，当我们没有让子线程休眠时，直接更新UI，系统还来不及检测当前线程是否UI线程，于是我们成功更新了UI，
而休眠二秒中后，ViewRootImpl已经实例化，此时更新UI就会抛出异常。
当然，在实际开发中，这意义不大，我们还是要在UI线程中更新UI。

十一、常见的两个问题

使用Handler常遇到的两个异常：
1、非UI线程更新UI
也就是我们上面遇到的问题
抛出这个异常：
 android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

2、子线程中创建Handler缺少Looper
抛出这个异常：
java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()

查看源码 
mLooper = Looper.myLooper();  
    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;  
}

发现，没有Looper，就会抛出这个运行时异常。

俊墨客
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android handle传值Demo
12-15
这个是个简单使用handle传递数据的Demo，里面用到了bundle去传值。有需要的可以下载
Android~Handler机制DEMO示例
ligangying的专栏
11-03 1040
大家好，在上一篇中我给大家介绍了Android~Handler机制自我理解
Android Handler
最新发布
liuning1985622的博客
05-02 702
Android Handler是一种事件驱动模型，用于实现线程切换或执行延时任务。它在整个Android开发体系中占据着很重要的地位，可以用于保证多个任务在执行时的有序性。在Android系统中，主线程有特殊地位，因此像EventBus和Retrofit这类并非Android独有的第三方库，都是通过Handler来实现对Android系统的特殊平台支持。Android Handler的主要作用是将消息(Message)或Runnable对象发送到主线程的消息队列中，以便在主线程中执行。
Android Handler Demo
weixin_30362083的博客
08-21 58
1 package com.mobile.free.hander; 2 3 import android.app.Activity; 4 import android.os.Bundle; 5 import android.content.Context; 6 import android.os.Handler; 7 import android.os.HandlerT...
Android——Handler详解
热门推荐
Yawn
05-27 6万+
1. 简介 Handler是一套 Android 消息传递机制 可以说只要有异步线程与主线程通信的地方就一定会有 Handler。 在多线程的应用场景中，将工作线程中需更新UI的操作信息 传递到 UI主线程，从而实现 工作线程对UI的更新处理，最终实现异步消息的处理 使用Handler消息传递机制主要是为了多个线程并发更新UI的同时，保证线程安全 2. 相关概念解释 Handler、Message、Message Queue、Looper Android消息机制： 以Handler的sendMes
Android基础——Handler消息传递机制解析
weixin_44901971的博客
10-27 1468
Android开发基础学习之Handler消息传递
android落花效果+字体渐变的Demo源码.rar
12-05
这个压缩包文件“android落花效果+字体渐变的Demo源码.rar”是针对Android平台的一个开发示例，主要展示了如何实现动态的“落花效果”以及文字的渐变动画。在Android应用开发中，这样的视觉特效可以增加用户体验，使...
进阶android源码demo
01-15
"进阶Android源码demo"提供了一系列的实践项目，包括游戏和聊天应用，为开发者提供了丰富的学习资源。下面，我们将深入探讨这些知识点，以帮助你更好地理解和应用Android源码。 1. **Android框架理解**：Android...
Android天气预报Demo源码
12-12
综上所述，这个Android天气预报Demo源码涵盖了网络请求、多线程通信、JSON解析和UI设计等核心知识点，是学习Android开发实战技能的一个良好实践案例。通过分析和理解源码，开发者不仅可以提升自己的编程技巧，还能...
androidjava源码-HandlerDemo:“深入了解Android消息机制和源码分析（Java层和Native层）”文章示例代码
05-20
\n\n总结来说，“HandlerDemo”是一个深入解析Android消息机制的实例，通过Java层和Native层的源码分析，可以帮助开发者更全面地了解Android系统内部的消息处理流程，这对于优化应用性能、避免UI卡顿等问题有着直接...
Android解析xml的Demo
04-16
本Demo主要展示了如何在Android环境中解析XML文件，包括DOM（文档对象模型）、SAX（简单API for XML）和Pull Parser三种解析方式。通过学习这个Demo，开发者可以深入理解XML解析的基本原理和实践技巧。 1. DOM解析...
android demo，主线程handle
01-25
android demo，主线程handle，工作线程handle，主线程handle的post Runnable的具体使用方法。
【Android 】零基础到飞升 | Handler消息传递机制浅析
m0_58523831的博客
07-09 5278
3.3 Handler消息传递机制浅析 分类 Android 基础入门教程 本节引言 前两节中我们对Android中的两种事件处理机制进行了学习，关于响应的事件响应就这两种；本节给大家讲解的 是Activity中UI组件中的信息传递Handler，相信很多朋友都知道，Android为了线程安全，并不允许我们在UI线程外操作UI；很多时候我们做界面刷新都需要通过Handler来通知UI组件更新！除了用Handler完成界面更新外，还可以使用runO...
Android——Handler一篇就看懂
未来源起的博客
06-07 5591
Android handler的详细讲解
Android每天一个知识点+Demo—异步消息机制实现
风雨与阳光
09-15 227
一 前言 Handler的由来 （1）首先为什么需要Handler呢？ 因为UI更新只能在UI线程。 （2）那为什么只能在UI线程更新UI呢？ 因为Android是单线程模型。 （3）那为什么Android是单线程模型？ 因为如果任意线程都可以更新UI的话，线程安全问题处理起来会相当麻烦复杂，所以就规定了Android是单线程...
android多线程三（Message，MessageQueue)
pipisky2006的专栏
01-14 1513
Message 定义一个包含任意类型的描述数据对象，此对象可以发送给Handler。 尽管Message的构造器是公开的，但是获取Message对象的最好方法是调用Message.obtain()或者Handler.obtainMessage(), 这样是从一个可回收对象池中获取Message对象。 Message类是个final类，就是说不能被继承，同时Message类实现了Pa
安卓 Handler 消息机制之MessageQueue源码
set_one_name的博客
10-15 542
handler机制之messagequeue源码
Android基础学习（二十一）—— Handler
123
12-09 1433
android基础之Handler
Android中Handler详解
Dakaring的专栏
02-08 1233
Android中Handler详解 Handler是什么 是Android中给我们提供的一套UI更新，消息的处理以及消息的发送的机制 其中有Handler，MessageQueue，Looper，Message 我们可以形象的将handler比喻成学生，将Loop比喻成老师，学生要和老师报告，要sendMessage，老师同意以后要执行Looper.looper，学生听到以后要去执行，则要ha
Android6.0 消息机制原理解析
09-01
主要为大家详细介绍了Android6.0 消息机制原理,具有一定的参考价值，感兴趣的小伙伴们可以参考一下

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值