Android Handler Message多线程实例
android handlerthread用法 -回复
android handlerthread用法-回复Android HandlerThread是Android开发中常用的多线程处理工具。
它能够在后台线程中执行任务，并通过Handler与UI线程进行通信。
本文将详细介绍HandlerThread的用法，以及如何使用它来实现多线程任务处理。
一、什么是HandlerThread？HandlerThread是Android中的一个类，继承自Thread，并实现了Looper接口。
它在后台线程中提供了一个消息循环机制，可以用来处理耗时的任务。
二、使用HandlerThread的步骤1. 创建HandlerThread实例首先，我们需要创建一个HandlerThread的实例，并给它一个有意义的名称。
例如，可以创建一个名为"BackgroundThread"的HandlerThread 实例：javaHandlerThread handlerThread = newHandlerThread("BackgroundThread");2. 启动HandlerThread接下来，我们需要调用HandlerThread的start方法来启动它的线程：javahandlerThread.start();3. 创建Handler然后，我们可以通过HandlerThread的getLooper方法获得一个Looper 实例，并将其用于创建一个Handler对象：javaHandler handler = new Handler(handlerThread.getLooper());通过这个Handler，我们可以在后台线程中发送和处理消息。
4. 发送消息现在我们可以在UI线程中通过Handler发送消息到后台线程中进行处理。
例如，我们可以发送一个Runnable对象到后台线程中执行：javahandler.post(new Runnable() {@Overridepublic void run() {在后台线程中执行耗时任务...}});5. 处理消息在HandlerThread的内部实现中，它会不断地从消息队列中取出消息并处理。
android studio中的多线程编程例子
android studio中的多线程编程例子在Android Studio中，多线程编程是一种常见且重要的技术，它可以帮助我们更有效地处理并发任务和提升应用的性能。
通过使用多线程，我们可以在应用中同时执行多个任务，从而提高用户体验。
下面我将为您提供一个Android Studio中的多线程编程的例子，帮助您更好地理解该概念和实现。
首先，我们需要在项目中创建一个新的Java类，用于定义我们的多线程任务。
假设我们要实现一个简单的计数器，可以在后台进行自增操作，并将结果显示在应用界面上。
```javapublic class CounterThread extends Thread {private boolean isRunning = true;private int counter = 0;private Handler handler;public CounterThread(Handler handler) {this.handler = handler;}@Overridepublic void run() {while (isRunning) {try {// 模拟自增操作counter++;// 发送消息给主线程更新UIMessage message = new Message();message.obj = "当前计数: " + counter;handler.sendMessage(message);// 使线程休眠1秒Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}public void stopThread() {isRunning = false;}}```在MainActivity中，我们需要处理UI更新的部分，以及创建和启动我们的CounterThread。
android handler实现线程通信的原理
android handler实现线程通信的原理Android中的Handler用于实现线程通信的原理主要依赖于消息机制。
Handler、Looper和MessageQueue三者协同工作，实现线程间的通信。
以下是Handler实现线程通信的原理：1. 主线程（UI线程）与子线程（Work线程）之间通过Handler进行通信。
主线程负责Android应用的界面管理与显示、与用户之间的交互，是最重要、最核心的线程。
子线程负责执行耗时操作，例如网络请求、文件读写等。
2. 主线程中创建Handler实例，并将其传递给子线程。
子线程通过Handler发送消息（Message）给主线程。
消息内容包括任务执行结果、数据等。
3. 主线程中的Handler接收子线程发送的消息，并通过处理消息（HandleMessage）方法进行相应的操作。
例如，更新界面、处理数据等。
4. 当子线程完成任务后，会通过Handler发送消息。
主线程收到消息后，将其放入消息队列（MessageQueue）中。
5. 主线程中的Looper不断地从消息队列中取出消息，并调用Handler 的HandleMessage方法进行处理。
这样，主线程就能在子线程完成后及时处理任务结果，避免界面卡顿、ANR等问题。
6. 如果主线程中需要执行耗时操作，也可以通过创建新的子线程并使用Handler进行通信，以实现线程的切换和任务分发。
总之，Android中的Handler实现线程通信的原理是通过消息机制，在主线程与子线程之间传递消息并处理任务。
Handler、Looper和MessageQueue三者共同协作，确保线程间通信的顺畅进行。
这种方式既保证了主线程的流畅性，又实现了子线程与主线程之间的数据传递，提高了应用程序的性能和用户体验。
Android多线程
Android多线程作者：陈正最本质的多线程：hanlder和message机制：为何需要多线程：在日常应用中，我们通常需要处理一些“后台，用户不可见”的操作，例如说，我们需要下载一个音乐，要是你的应用必须等用户下载完成之后才可以进行别的操作，那肯定让用户非常的不爽。
这时候，我们通常的做法是，让这些操作去后台执行，然后等后台执行完毕之后，再给用户弹出相应的提示信息。
这时候，我们就需要使用多线程机制，然后通过创建一个新的线程来执行这些操作。
明白了，实现需求，我们就准备着手实现了。
但是，经过进一步的了解，我们悲剧的发现，android中的线程机制是，只能在UI线程中和用户进行交互。
当我们创建了一个新线程，执行了一些后台操作，执行完成之后，我们想要给用户弹出对话框以确认，但是却悲剧的发现，我们根本无法返回UI主线程了。
（说明：何为UI线程：UI线程就是你当前看到的这些交互界面所属的线程）。
这时候，我们如果想要实现这些功能，我们就需要一个android为我们提供的handler 和message机制。
先讲解下编程机制：我们通常在UI线程中创建一个handler，handler相当于一个处理器，它主要负责处理和绑定到该handler的线程中的message。
每一个handler都必须关联一个looper，并且两者是一一对应的，注意，这点很重要哦！此外，looper负责从其内部的messageQueue中拿出一个个的message给handler进行处理。
因为我们这里handler是在UI线程中实现的，所以经过这么一个handler、message机制，我们就可以回到UI线程中了。
何为handler：处理后台进程返回数据的工作人员。
何为message：后台进程返回的数据，里面可以存储bundle等数据格式何为messageQueue：是线程对应looper的一部分，负责存储从后台进程中抛回的和当前handler绑定的message，是一个队列。
handlemessage基本用法
handlemessage基本用法
`Handler` 的基本用法涉及到Android中的消息机制，主要用于线程间的通信。
以下是它的基本用法步骤：
1. 创建Handler对象：通常在主线程中创建一个Handler实例，因为Handler与创建它的线程的Looper紧密相关。
2. 定义消息：通过创建Message对象并设置其属性，如目标Handler、要执行的代码（Runnable）或要传递的数据。
3. 发送消息：使用Handler的`sendMessage(Message msg)`方法将消息发送到消息队列中。
如果需要立即处理消息，可以使用`handleMessage(Message msg)`方法。
4. 处理消息：重写Handler的`handleMessage(Message msg)`方法来定义当消息被处理时应该执行的操作。
5. 消息循环：每个Looper会不断从其消息队列中读取并处理消息，直到队列为空或者调用了`quit()`或`quitSafely()`方法。
这种机制允许开发者在不同的线程间传递和处理信息，而不必担心线程安全问题，因为所有的处理操作都会在创建Handler的那个线程中执行。
Android应用开发中的多线程编程技术详解
Android应用开发中的多线程编程技术详解在Android应用中，当我们需要执行一些耗时的操作，例如网络请求、磁盘读写等，如果在主线程中执行，会导致UI界面卡顿，用户体验下降。
而解决这个问题的办法就是使用多线程编程技术。
本文将详细介绍Android应用开发中的多线程编程技术。
1. 线程的基础知识在Java中，线程就是一个独立的执行单元，它可以独立运行，也可以和其它线程一起协作完成任务。
而在Android中，我们常用的线程有两种：主线程和子线程。
主线程是Android应用的UI线程，负责响应用户的交互事件，执行UI更新操作；而子线程则是我们在应用中创建的线程，用于执行耗时的操作。
在Java中，有两种方式来创建线程：继承Thread类和实现Runnable接口。
其中，实现Runnable接口是更加常用的做法，因为它能够避免单继承的限制。
下面是一个简单的示例代码，实现了一个通过实现Runnable接口创建子线程的例子：```public class MyThread implements Runnable {@Overridepublic void run() {// 子线程要执行的任务}}// 在主线程中创建子线程MyThread myThread = new MyThread();Thread thread = new Thread(myThread);thread.start();```当我们创建了一个子线程后，它就会独立地运行在一个新的线程中。
在子线程中，我们可以执行一些耗时的操作，并且不会卡住主线程。
2. Android中的主线程在Android应用中，主线程是非常重要的，它负责维护UI界面的显示和交互，处理用户的输入事件，并更新UI的状态。
因此，在主线程中执行一些耗时的操作，就会使得UI界面出现卡顿现象，用户体验大大降低。
为了避免这种情况，Android系统引入了一种机制，叫做ANR （Application Not Responding）。
android handler实现线程通信的原理
android handler实现线程通信的原理一、Android Handler简介Android Handler是Android开发中常用的一种线程通信工具，它能够实现主线程与子线程之间的消息传递和数据交换。
Handler的主要作用是解决Android中由于线程不同步导致的UI更新问题，保证主线程能够及时接收到子线程的数据并更新UI。
二、Handler线程通信原理1.创建Handler对象：在主线程中创建一个Handler实例，并将其与子线程关联。
2.发送消息：在子线程中，通过Handler的sendMessage()方法向主线程发送消息。
消息包含数据和消息类型，数据可以是任意类型的对象。
3.处理消息：在主线程中，通过Handler的handleMessage()方法处理子线程发送的消息。
此方法会在子线程消息发送后的第一时间被调用。
4.发布消息：在子线程中，通过Handler的post()方法发布消息。
这条消息会被添加到消息队列中，等待主线程处理。
5.处理消息：在主线程中，通过Handler的handleMessage()方法处理子线程发布的消息。
三、实践中的应用1.下载进度显示：在下载文件时，使用Handler将下载进度通知到主线程，主线程更新UI显示下载进度。
2.网络请求回调：在网络请求回调中，使用Handler将请求结果通知主线程，主线程根据结果更新UI。
3.子线程操作：在需要操作硬件或耗时较长的子线程中，使用Handler与主线程通信，防止阻塞主线程。
四、优缺点分析优点：1.保证了主线程能够及时接收到子线程的数据，避免卡顿。
2.支持跨线程通信，易于实现。
缺点：1.学习成本较高，初学者不易上手。
2.性能较差，当子线程发送大量消息时，可能导致内存占用增加。
综上，Handler是Android开发中一种重要的线程通信工具，能够实现主线程与子线程之间的消息传递和数据交换。
Android消息机制（Handler，Looper，MessageQueue，Message）
Android消息机制（Handler，Looper，MessageQueue，Message） android的消息处理有三个核⼼类：Looper,Handler和Message。
其实还有⼀个Message Queue（消息队列），但是MQ被封装到Looper⾥⾯了，Handler扮演了往MQ上添加消息和处理消息的⾓⾊（只处理由⾃⼰发出的消息），即通知MQ它要执⾏⼀个任务(sendMessage)，并在loop到⾃⼰的时候执⾏该任务(handleMessage)，整个过程是异步的。
消息处理过程如下图所⽰：Handler主要涉及到的内容有： Handler 、 Handler.Callback、AsyncQueryHandler Looper、 HandlerThread、Runnable Message、Message queueLooperAndroid官⽅⽂档中Looper的介绍：Class used to run a message loop for a thread. Threads by default do not have a message loop associated with them; to create one, call prepare() in the thread that is to run the loop, and then loop() to have it process messages until the loop is stopped.Most interaction with a message loop is through the Handler class.This is a typical example of the implementation of a Looper thread, using the separation of prepare() and loop() to create an initial Handler to communicate with the Looper.View Code1class LooperThread extends Thread {23public Handler mHandler;45public void run() {67 Looper.prepare();89 mHandler = new Handler() {1011public void handleMessage(Message msg) {1213// process incoming messages here1415 }1617 };1819 Looper.loop();2021 }2223 }Android中的Looper类，是⽤来封装消息循环和消息队列的⼀个类，⽤于在android线程中进⾏消息处理。
handler中sendmessage和obtainmessage的用法
handler中sendmessage和obtainmessage的用法在Android开发中，Handler是用于在UI线程外处理消息的重要工具。
它提供了两种方法来发送和获取消息：sendMessage和obtainMessage。
这些方法在消息处理中起着至关重要的作用，下面我们来详细了解一下它们的用法。
一、sendMessage方法sendMessage方法用于向消息队列发送一个普通消息。
它需要传入一个Message对象作为参数，该对象包含了要执行的操作和附加的数据。
以下是sendMessage方法的用法示例：```java```其中，handler是要发送消息的Handler对象。
通过这种方式，消息将被添加到消息队列中，等待在适当的时机执行。
二、obtainMessage方法obtainMessage方法用于从消息队列中获取一个已存在的消息。
它不需要任何参数，返回一个包含附加数据的Message对象。
以下是obtainMessage的用法示例：```javaMessage msg = handler.obtainMessage();```通过这种方式，我们可以在适当的时候使用这个Message对象来执行操作。
需要注意的是，obtainMessage方法返回的Message对象必须被释放，以便回收资源，可以通过调用recycle()方法来实现这一点。
三、处理消息的逻辑当消息被添加到消息队列中时，它们会按照队列的顺序执行。
这意味着最早添加的消息将首先被执行，依此类推。
可以使用以下代码示例来演示如何处理消息：1. 使用obtainMessage获取消息：```javaMessage msg = handler.obtainMessage();msg.sendToTarget(); // 发送消息到目标处理器```2. 在目标处理器中处理消息：在Android中，默认的目标处理器就是UI线程。
在目标处理器中，我们可以通过调用msg.what来获取消息的标识符，并执行相应的操作。
handler 消息机制案例
handler 消息机制案例Handler 消息机制是一种常见的编程模式，用于在程序中处理异步消息和事件。
通过使用Handler，可以实现线程间的通信和协作，使得程序的逻辑更加清晰和高效。
下面是10个使用Handler消息机制的案例：1. 定时任务调度：通过Handler的postDelayed()方法，可以在指定的时间间隔后执行任务，实现定时任务调度的功能。
例如，可以使用Handler来实现每隔一段时间更新UI界面的操作。
2. 网络请求处理：在进行网络请求时，通常需要在子线程中执行网络操作，然后将结果返回到主线程进行UI更新。
通过使用Handler，可以在子线程中处理网络请求的结果，并通过Handler的sendMessage()方法将结果发送到主线程进行处理。
3. 多线程协作：在多线程编程中，经常需要进行线程间的通信和协作。
通过使用Handler，可以实现线程之间的消息传递和同步。
例如，可以使用Handler来实现生产者-消费者模式，其中生产者线程通过Handler发送消息，消费者线程通过Handler接收消息并处理。
4. UI事件处理：在Android开发中，UI事件通常需要在主线程中处理。
通过使用Handler，可以将UI事件的处理逻辑放在Handler 的handleMessage()方法中，实现UI事件的异步处理。
5. 任务队列管理：通过使用Handler的消息队列，可以实现任务队列的管理。
例如，可以使用Handler来管理下载任务队列，将下载任务按照先后顺序加入到消息队列中，并通过Handler的sendMessage()方法逐个执行下载任务。
6. 消息传递和同步：在分布式系统中，经常需要进行消息传递和同步。
通过使用Handler，可以实现不同节点之间的消息传递和同步。
例如，可以使用Handler来实现分布式系统中的节点间通信。
7. 状态机实现：通过使用Handler的消息机制，可以实现状态机的功能。
深入Android的消息机制源码详解～Handler,MessageQueue与Looper关系
深入Android的消息机制源码详解～Handler,MessageQueue与Looper关系一说到Android的消息机制，自然就会联想到Handler，我们知道Handler是Android消息机制的上层接口，因此我们在开发过程中也只需要和Handler交互即可，很多人认为Handler 的作用就是更新UI,这也确实没错，但除了更新UI，Handler其实还有很多其他用途，比如我们需要在子线程进行耗时的I/O操作，可能是读取某些文件或者去访问网络等，当耗时操作完成后我们可能需要在UI上做出相应的改变，但由于Android系统的限制，我们是不能在子线程更新UI控件的，否则就会报异常，这个时候Handler就可以派上用场了，我们可以通过Handler切换到主线程中执行UI更新操作。
下面是Handler一些常用方法：void handleMessage(Message msg):处理消息的方法，该方法通常会被重写。
final boolean hasMessages(int what):检测消息队列中是否包含what属性为指定值的消息。
Message obtainMessage():获取消息的方法，此函数有多个重载方法。
sendEmptyMessage(int what):发送空消息。
final boolean sendEmptyMessageDelayed(int what , long delayMillis):指定多少毫秒后发送空消息。
final boolean sendMessage(Message msg):立即发送消息。
final boolean sendMessageDelayed(Message msg ,long delayMillis):指定多少毫秒后发送消息。
final boolean post(Runnable r):执行runnable操作。
final boolean postAtTime(Runnable r, long upTimeMillis):在指定时间执行runnable操作。
Android中Handler与Message的简单实例
Android中Handler与Message的简单实例Android中Handler与Message的简单实例前⾔：虽然笔者已经学习了Android的AsyncTask来实现⼀部消息的处理。
但是在android的学习中，经常会在⼀些demo中看到Handler与Message的⼀些使⽤，所以Handler与Message的学习也是有必要了。
⾄于学多少，笔者还是⽐较坚持⾃⼰的看法，“⽤多少，学多少”，毕竟已经有了AsyncTask如此⽅便的东西，Handler与Message也不是那么必不可缺了。
(如此⽂的简单了解⼀下还是不需要花太多时间的)此实例是在handler中更新textview的内容，新⼿读者可能会问为什么不直接在oncreate中⼀⾏解决呢？还是主要是需求问题，倘若我们需要在⼦线程中从⽹上获取内容，然后更新到textview中，那么直接写在主线程中不合理的。
但是由于此实例主要是⼀个参考作⽤，并且让它更能让新⼿理解，所以并没有写从⽹络获取内容的代码了。
（直接在⼦线程中是不能执⾏更新UI的操作的，程序会崩溃）上⼀下效果图：分别是点击button前后效果直接看⼀下概念与代码：Message:Message是在线程之间传递的消息，它可以在内部携带少量的信息，⽤于再不同线程之间交换数据。
除了what字段，还可以⽤arge1和arg2字段来携带⼀些整型数据，使⽤obj字段携带⼀个Object对象。
HandlerHandler顾名思义就是处理者的意思，它主要是⽤于发送和处理消息的。
发送消息⼀般是使⽤Handler的sendMessage()⽅法，⽽发出的消息经过⼀系列地辗转处理后，最终会传递到Handler的handleMessage()⽅法中。
MainActivity:1import android.app.Activity;2import android.os.Bundle;3import android.os.Handler;4import android.os.Message;5import android.view.View;6import android.view.View.OnClickListener;7import android.widget.Button;8import android.widget.TextView;910public class MainActivity extends Activity implements OnClickListener {1112//定义UPDATE_TEXT这个整型敞亮，⽤于表⽰更新TextView这个动作13public static final int UPDATE_TEXT = 1;1415private TextView text;16private Button changeText;1718//创建⼀个Handler19private Handler handler = new Handler() {2021public void handleMessage(Message msg) {22switch (msg.what) {23case UPDATE_TEXT:24//在这⾥可以进⾏UI操作25//对msg.obj进⾏String强制转换26 String string=(String)msg.obj;27 text.setText(string);28break;29default:30break;31 }32 }3334 };3536 @Override37protected void onCreate(Bundle savedInstanceState) {38super.onCreate(savedInstanceState);39 setContentView(yout.activity_main);40 text = (TextView) findViewById(R.id.text);41 changeText = (Button) findViewById(R.id.change_text);42 changeText.setOnClickListener(this);43 }4445 @Override46public void onClick(View v) {47switch (v.getId()) {48case R.id.change_text:49new Thread(new Runnable() {50 @Override51public void run() {52//创建⼀个message53//设置what字段的值为UPDATE_TEXT,主要是为了区分不同的message 54//设置message.obj的内容55//调⽤Handler的message对象56//handler中的handlermessage对象是在主线程中运⾏的57 String string="Nice to meet you";58 Message message = new Message();59 message.what = UPDATE_TEXT;60 message.obj=string;61 handler.sendMessage(message);62 }63 }).start();64break;65default:66break;67 }68 }6970 }activity_main:1 <RelativeLayout xmlns:android="/apk/res/android"2 android:layout_width="match_parent"3 android:layout_height="match_parent" >45 <Button6 android:id="@+id/change_text"7 android:layout_width="match_parent"8 android:layout_height="wrap_content"9 android:text="Change Text" />1011 <TextView12 android:id="@+id/text"13 android:layout_width="wrap_content"14 android:layout_height="wrap_content"15 android:layout_centerInParent="true"16 android:text="Hello world"17 android:textSize="20sp" />1819 </RelativeLayout>。
android message机制
android message机制Android消息机制是Android系统中用于处理线程间通信的一种机制。
它允许在不同的线程之间发送和接收消息，从而实现线程间的数据传递和协作。
Android消息机制主要包括以下几个关键组件和概念：1. Handler：Handler是Android消息机制的核心类，用于发送和处理消息。
每个Handler实例都与一个特定的线程关联，用于处理该线程收到的消息。
Handler可以通过sendMessage()方法发送消息，也可以通过post()方法发送Runnable对象。
2. Looper：Looper是一个消息循环器，负责处理消息队列中的消息。
每个线程只能有一个Looper实例，通过调用Looper.prepare()和Looper.loop()方法来创建和启动Looper。
Looper.prepare()会创建一个消息队列，Looper.loop()会开启一个无限循环来处理消息队列中的消息。
3. Message：Message是消息的载体，包含了要传递的数据和相关的处理信息。
可以通过调用Handler的obtainMessage()方法获取一个Message对象，并通过Message的what、arg1、arg2和obj属性设置消息的内容。
4. MessageQueue：MessageQueue是一个消息队列，用于存储要处理的消息。
每个Looper实例都有一个唯一的MessageQueue实例，所有的消息都会先被添加到MessageQueue中，然后由Looper按照特定的顺序取出并分发给相应的Handler处理。
通过使用Handler、Looper、Message和MessageQueue这些组件，Android消息机制可以实现在不同线程之间安全、可靠地发送和处理消息，从而实现线程间的通信和协作。
AndroidHandler使用实例
AndroidHandler使⽤实例本⽂主要介绍Android中Handler的简单使⽤⽅法，Handler跟多线程，消息队列联系很紧密，在平常的实际程序开发中⽐较常见。
本⽂分为4个简单的例⼦来学校handlerHandler使⽤例1这个例⼦是最简单的介绍handler使⽤的,是将handler绑定到它所建⽴的线程中.本次实验完成的功能是:单击Start按钮，程序会开始启动线程，并且线程程序完成后延时1s会继续启动该线程，每次线程的run函数中完成对界⾯输出 nUpdateThread...⽂字，不停的运⾏下去，当单击End按钮时，该线程就会停⽌，如果继续单击Start，则⽂字⼜开始输出了。
软件界⾯如下：实验主要部分代码和注释：MainActivity.java:package com.example.handler1;import android.app.Activity;import android.os.Bundle;import android.os.Handler;import android.view.Menu;import android.view.View;import android.view.View.OnClickListener;import android.widget.Button;import android.widget.TextView;public class MainActivity extends Activity {private TextView text_view = null;private Button start = null;private Button end = null;//使⽤handler时⾸先要创建⼀个handlerHandler handler = new Handler();//要⽤handler来处理多线程可以使⽤runnable接⼝，这⾥先定义该接⼝//线程中运⾏该接⼝的run函数Runnable update_thread = new Runnable(){public void run(){//线程每次执⾏时输出"UpdateThread..."⽂字,且⾃动换⾏//textview的append功能和Qt中的append类似，不会覆盖前⾯//的内容，只是Qt中的append默认是⾃动换⾏模式text_view.append("\nUpdateThread...");//延时1s后⼜将线程加⼊到线程队列中handler.postDelayed(update_thread, 1000);}};@Overridepublic void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.activity_main);text_view = (TextView)findViewById(R.id.text_view);start = (Button)findViewById(R.id.start);start.setOnClickListener(new StartClickListener());end = (Button)findViewById(R.id.end);end.setOnClickListener(new EndClickListener());}private class StartClickListener implements OnClickListener{public void onClick(View v) {// TODO Auto-generated method stub//将线程接⼝⽴刻送到线程队列中handler.post(update_thread);}}private class EndClickListener implements OnClickListener{public void onClick(View v) {// TODO Auto-generated method stub//将接⼝从线程队列中移除handler.removeCallbacks(update_thread);}}@Overridepublic boolean onCreateOptionsMenu(Menu menu) {getMenuInflater().inflate(R.menu.activity_main, menu);return true;}}activity_main.xml:<LinearLayout xmlns:android="/apk/res/android"xmlns:tools="/tools"android:layout_width="match_parent"android:layout_height="match_parent"android:orientation="vertical" ><TextViewandroid:id="@+id/text_view"android:layout_width="fill_parent"android:layout_height="200dip"android:text="@string/hello_world"tools:context=".MainActivity" /><Buttonandroid:id="@+id/start"android:layout_width="fill_parent"android:layout_height="wrap_content"android:text="@string/start"/><Buttonandroid:id="@+id/end"android:layout_width="fill_parent"android:layout_height="wrap_content"android:text="@string/end"/></LinearLayout>Handler使⽤例2这个例⼦⽐刚才那个例⼦稍微复杂些。
AndroidHandler使用案例详解
AndroidHandler使⽤案例详解什么是Handler？Handler可以发送和处理消息对象或Runnable对象，这些消息对象和Runnable对象与⼀个线程相关联。
每个Handler的实例都关联了⼀个线程和线程的消息队列。
当创建了⼀个Handler对象时，⼀个线程或消息队列同时也被创建，该Handler对象将发送和处理这些消息或Runnable对象。
handler类有两种主要⽤途：执⾏Runnable对象，还可以设置延迟。
两个线程之间发送消息，主要⽤来给主线程发送消息更新UI。
为什么要⽤Handler解决多线程并发问题，假设如果在⼀个activity中，有多个线程去更新ui，并且都没有加锁机制，那界⾯显⽰肯定会不正常。
于是andoird官⽅就封装了⼀套更新ui的机制，也可以⽤handler来实现多个线程之间的消息发送。
如何使⽤Handlerhandler常⽤的⽅法有以下这些:post（Runnable）postAtTime（Runnable，long）postDelayed（Runnable，long）sendEmptyMessage（int）sendMessage（Message）sendMessageAtTime（Message，long）sendMessageDelayed（Message，long）我们可以看到这些⽅法主要分为两类，⼀种是传⼊⼀个Runnable对象，⼀种是传⼊⼀个Message对象。
⽤代码来学习post⼀个Runnable对象先创建Handler对象，直接new⼀个就⾏private Handler handler=new Handler();实现Runnable接⼝,⽤匿名实现⽅式,重写run⽅法，就打印⼀个字符串。
private Runnable runnable=new Runnable() {@Overridepublic void run() {Log.i("MainActivity","Handler Runnable");}};然后我们调⽤handler的post⽅法，这⾥需要注意的是，post⼀个Runnable对象，底层⽤的是回调，不会开启⼀个新的线程，所有Runnable的run⽅法还是在主线程⾥⾯。
handlemessage方法
handlemessage方法handleMessage方法是Android开发中非常重要的一个方法，它在Activity、Service、BroadcastReceiver等组件中被广泛使用。
这个方法的作用是接收并处理来自其他组件或线程的消息。
我们来看一下handleMessage方法的基本结构。
在Android中，handleMessage方法通常是定义在Handler的子类中的，它的形参是一个Message对象，返回值为void。
开发者需要根据具体的需求来重写这个方法，实现自己的逻辑。
在handleMessage方法中，我们可以根据不同的消息类型来执行不同的操作。
通常情况下，我们会使用switch语句来判断消息的类型，并根据不同的类型执行相应的逻辑。
下面我们来举一个例子来说明handleMessage方法的使用。
假设我们有一个音乐播放器的应用，我们需要使用handleMessage方法来接收并处理来自用户界面的消息。
在这个例子中，我们定义了几种不同的消息类型，分别是播放、暂停、停止和切换歌曲。
当用户在界面上点击相应的按钮时，就会发送对应的消息，然后通过handleMessage方法来处理这些消息。
我们需要定义一些常量来表示不同的消息类型：```private static final int MSG_PLAY = 1;private static final int MSG_PAUSE = 2;private static final int MSG_STOP = 3;private static final int MSG_NEXT = 4;private static final int MSG_PREVIOUS = 5;```然后，在handleMessage方法中，我们可以根据不同的消息类型执行相应的操作。
例如，当收到播放消息时，我们可以调用音乐播放器的播放方法；当收到暂停消息时，我们可以调用暂停方法；当收到停止消息时，我们可以调用停止方法；当收到切换歌曲消息时，我们可以调用切换歌曲方法。
线程的使用 三种方式 Android中常用定时器
线程的使用三种方式Android中常用定时器在Android 中，经常用到的定时器主要有以下几种实现：一、采用Handler与线程的sleep(long )方法二、采用Handler的postDelayed(Runnable, long) 方法三、采用Handler与timer及TimerTask结合的方法。
下面逐一介绍：一、采用Handle与线程的sleep(long )方法Handler主要用来处理接受到的消息。
这只是最主要的方法，当然Handler里还有其他的方法供实现，有兴趣的可以去查API，这里不过多解释。
1.定义一个Handler类，用于处理接受到的Message. Handler handler = new Handler() {public void handleMessage(Message msg) {//要做的事情super.handleMessage(msg);}};2.新建一个实现Runnable接口的线程类。
如下：public class MyThread implements Runnable{@Overridepublic void run() {// TODO Auto-generated method stubwhile (true) {try {Thread.sleep(10000);//线程暂停10秒，单位毫秒Message message=new Message();message.what=1;handler.sendMessage(message);//发送消息} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}3.在需要启动线程的地方加入下面语句：new Thread(new MyThread()).start();4.启动线程后，线程每10s发送一次消息。
android中使用多线程——HandlerThread举例
android中使用多线程——HandlerThread举例2011-12-02 标签: android 多线程 HandlerThread public class HandlerTest2 extends Activity{ @Override public void onCreate(BundlesavedInstanceState){ super .onCreate(savedInstanceStat e); setContentView(yout.main); System.out.println( Activity--+Thread.currentThread().getId()+Thread1.public class HandlerTest2 extends Activity {2. @Override3. public void onCreate(Bundle savedInstanceState) {4. super.onCreate(savedInstanceState);5. setContentView(yout.main);6. System.out.println("Activity-->"+Thread.currentThread().getId()+Thread.currentThread().getName());7. //创建一个名为ActivityHandler的线程8. HandlerThread handlerThread = new HandlerThread("ActivityHandler");9. //在使用handlerThread的getLooper()之前，要首先调用start()方法10. handlerThread.start();11. MyHandler myHandler = new MyHandler(handlerThread.getLooper());12. Message msg = myHandler.obtainMessage();13. Bundle bundle = new Bundle();14. bundle.putString("name", "Mary");15. bundle.putInt("age", 20);16. msg.setData(bundle);17. //将msg发送到目标对象，所谓的目标对象，就是生成该msg对象的handler对象，本例中即为myHandler18. msg.sendToTarget();19. }20.}21.class MyHandler extends Handler{22.public MyHandler() {23.super();24.}25.public MyHandler(Looper looper) {26.super(looper);27.}28.@Override29.public void handleMessage(Message msg) {30.super.handleMessage(msg);31.Bundle b = msg.getData();32.String name = b.getString("name");33.int age = b.getInt("age");34.System.out.println(name+"--"+age);35.System.out.println("MyHandler-->"+Thread.currentThread().getId()+Thread.currentThread().getName());36.}37.}其中用到一个Bundle类，API中这样解释——A mapping from String values to various Parcelable types.我们可以将其理解成一种特殊的HashMap。
Android消息机制之Handler,MessageQueue,Looper源码剖析
Android消息机制之Handler,MessageQueue，Looper源码剖析Android线程间通讯方式有很多，但是大部分内部实现其实都是handler。
今天我们就来看看handler的内部实现机制，实现原理，实现细节。
本文主要是为了搞清楚线程间的通讯，Message也可以用于进程间的通讯，在本文中不对此进行详细的讲解，浅尝辄止！后面如果有需要，我会补上Message的进程间通讯相关文章，敬请期待！本位我们分步骤对Handler消息机制进行分析，这样有条理一点，已更利于阅读。
角色分析：Handler进程间通讯主要关联了Thread，ThreadLocal，Handler，Message,MessageQueue,Looper,，这几个类在内。
我们先看看这几个类各自在这个实现工程中扮演者什么样的角色！Thread：整个机制产生的意义，所有这个机制就是为Thread服务！Looper的创建是为Thread 而创建，其实是Thread持有。
Handler使用的Looper是由Thread提供！ThreadLocal：Thread属性的存储者，内部维护一个ThreadLocalMap，其中存放了Thread 的所有属性，Looper就是存放在这儿。
Handler：消息的发起者，发出一个消息。
消息的处理者，消息处理的时间到了对该消息进行处理。
必须有一个Looper，通过操作Looper持有的MessageQueue实现消息的发送，当Looper通知处理Message的时候，对Message进行处理。
Message：数据和信号携带者，携带数据进行传递。
处理时机决定者，通过when属性决定消息的处理时间。
消息队列的产生者，将一个个的message对象串联起来，形成消息队列。
MessageQueue：消息存放者，存放了一个消息队列，有消息进来的时候安插在指定的位置，需要处理的时候将消息取出来。
消息排队者，将消息按处理的时间进行存放,让消息排队进行处理。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
38.
39. LinearLayout layout = new LinearLayout(this);
40. youtParams params = new youtParams(250, 50);
Handler类的常用方法
方法签名
描 述
public void leMessage (Message msg)
子类对象通过该方法接收信息
public final boolean sendEmptyMessage (int what)
发送一个只含有 what 值的消息
有 what 值的消息
public final boolean post (Runnable r)
将一个线程添加到消息队列
开发带有Handler类的程序步骤如下。
在Activity或Activity的Widget中开发Handler类的对象，并重写handleMessage方法。
参考：/~Simon_fu/?p=652
虽说 特定线程的消息只能分发给本线程，不能进行跨线程通讯，但是由于可以通过获得线程的Looper对象来进行曲线的实现不同线程间消息的传递，代码如下
[java] view plaincopyprint?
19.
20. private NoLooperThread noLooperThread = null;
21. private OwnLooperThread ownLooperThread = null;
22. private ReceiveMessageThread receiveMessageThread =null;
33. private TextView tv = null;
34. /** Called when the activity is first created. */
35. @Override
36. public void onCreate(Bundle savedInstanceState) {
46. btn1.setOnClickListener(this);
47. layout.addView(btn1, params);
48.
49. btn2 = new Button(this);
50. btn2.setId(102);
51. btn2.setText("message from other thread to main thread");
52. btn2.setOnClickListener(this);
53. layout.addView(btn2,params);
82. params = new youtParams(LayoutParams.FILL_PARENT,LayoutParams.WRAP_CONTENT);
28. private Button btn2 = null;
29. private Button btn3 = null;
30. private Button btn4 = null;
31. private Button btn5 = null;
32. private Button btn6 = null;
01.package com.mytest.handlertest;
02.import android.app.Activity;
03.import android.graphics.Color;
04.import android.os.Bundle;
05.import android.os.Handler;
11.import youtParams;
12.import android.widget.Button;
13.import android.widget.LinearLayout;
14.import android.widget.TextView;
15.public class HandlerTest extends Activity implements OnClickListener{
16.
17. private String TAG = "HandlerTest";
18. private boolean bpostRunnable = false;
72.
73. btn6 = new Button(this);
74. btn6.setId(106);
75. btn6.setText("exit");
76. btn6.setOnClickListener(this);
public final boolean sendMessage (Message msg)
发送消息到 Handler ，
通过 handleMessage 方法接收
public final boolean hasMessages (int what)
监测消息队列中是否还
在新启动的线程中调用sendEmptyMessage或者sendMe ssage方法向Handler发送消息。
Handler类的对象用handleMessage方法接收消息，然后根据消息的不同执行不同的操作。
在Android 中Handler和Message、Thread有着很密切的关系。Handler 主要是负责Message的分发和处理。但是这个Message从哪里来的呢？Message 由一个消息队列进行管理，而消息队列却由一个Looper进行管理。Android系统中Looper负责管理线程的消息队列和消息循环，具体实现请参考Looper的源码。 可以通过Loop.myLooper()得到当前线程的Looper对象，通过Loop.getMainLooper()可以获得当前进程的主线程的 Looper对象。 Android系统的消息队列和消息循环都是针对具体线程的，一个线程可以存在（当然也可以不存在）一个消息队列和一个消息循环（Looper），特定线程的消息只能分发给本线程，不能进行跨线程，跨进程通讯。但是创建的工作线程默认是没有消息循环和消息队列的，如果想让该线程具有消息队列和消息循环，需要在线程中首先调用Looper.prepare()来创建消息队列，然后调用Looper.loop()进入消息循环。
59. layout.addView(btn3, params);
60.
61. btn4 = new Button(this);
62. btn4.setId(104);
63. btn4.setText("message with Runnable as callback from other thread to main thread");
23.
24. private Handler mOtherThreadHandler=null;
25. private EventHandler mHandler = null;
26.
27. private Button btn1 = null;
69. btn5.setText("main thread's message to other thread");
70. btn5.setOnClickListener(this);
71. layout.addView(btn5, params);
77. layout.addView(btn6, params);
78.
79. tv = new TextView(this);
80. tv.setTextColor(Color.WHITE);
81. tv.setText("");
Android Handler Message多线程实例 .
分类： Android 机制 2011-03-06 21:12 8286人阅读 评论(6) 收藏 举报
androidthreadbuttonstringnullcallback什么是Handler
handler通俗一点讲就是用来在各个进程之间发送数据的处理对象。在任何进程中，只要获得了另一个进程的handler则可以通过 handler.sendMessage(message)方法向那个进程发送数据。基于这个机制，我们在处理多线程的时候可以新建一个thread，这个thread拥有UI线程中的一个handler。当thread处理完一些耗时的操作后通过传递过来的handler像ui线程发送数据，由UI线程去更新界面。
Handler类简介
在Android平台中，新启动的线程是无法访问Activity里的Widget的，当然也不能将运行状态外送出来，这就需要有Handler机制进行消息的传递了，Handler类位于android.os包下，主要的功能是完成Activity的Widget与应用程序中线程之间的交互。接下来对该类中常用的方法进行介绍，如下表所示。
64. btn4.setOnClickListener(this);
65. layout.addView(btn4, params);
66.
67. btn5 = new Button(this);
68. btn5.setId(105);
54.
55. btn3 = new Button(this);
56. btn3.setId(103);
57. btn3.setText("message to other thread from itself");