您的位置：首页 > 移动开发 > Android开发

Android之Handler用法总结

2013-11-19 10:22 603 查看

转自：http://www.cnblogs.com/devinzhang/archive/2011/12/30/2306980.html

方法一：(java习惯，在android平台开发时这样是不行的，因为它违背了单线程模型）

刚刚开始接触android线程编程的时候，习惯好像java一样，试图用下面的代码解决问题

new Thread( new Runnable() {
public void run() {
myView.invalidate();
}
}).start();

可以实现功能，刷新UI界面。但是这样是不行的，因为它违背了单线程模型：Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行。

方法二：（Thread+Handler)

查阅了文档和apidemo后，发觉常用的方法是利用Handler来实现UI线程的更新的。

Handler来根据接收的消息，处理UI更新。Thread线程发出Handler消息，通知更新UI。

Handler myHandler = new Handler() {
public void handleMessage(Message msg) {
switch (msg.what) {
case TestHandler.GUIUPDATEIDENTIFIER:
myBounceView.invalidate();
break;
}
super.handleMessage(msg);
}
};

class myThread implements Runnable {
public void run() {
while (!Thread.currentThread().isInterrupted()) {

Message message = new Message();
message.what = TestHandler.GUIUPDATEIDENTIFIER;

TestHandler.this.myHandler.sendMessage(message);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
}

以上方法demo看:http://rayleung.javaeye.com/blog/411860

方法三：（java习惯。Android平台中，这样做是不行的，这跟Android的线程安全有关）

在Android平台中需要反复按周期执行方法可以使用Java上自带的TimerTask类，TimerTask相对于Thread来说对于资源消耗的更低，除了使用Android自带的AlarmManager使用Timer定时器是一种更好的解决方法。我们需要引入import java.util.Timer; 和 import java.util.TimerTask;

public class JavaTimer extends Activity {

Timer timer = new Timer();
TimerTask task = new TimerTask(){
public void run() {
setTitle("hear me?");
}
};

public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

timer.schedule(task, 10000);

}
}

方法四：(TimerTask + Handler)

通过配合Handler来实现timer功能的！

public class TestTimer extends Activity {

Timer timer = new Timer();
Handler handler = new Handler(){
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
setTitle("hear me?");
break;
}
super.handleMessage(msg);
}

};

TimerTask task = new TimerTask(){
public void run() {
Message message = new Message();
message.what = 1;
handler.sendMessage(message);
}
};

public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

timer.schedule(task, 10000);
}
}

方法五：( Runnable + Handler.postDelayed(runnable,time) )

在Android里定时更新 UI，通常使用的是 java.util.Timer, java.util.TimerTask, android.os.Handler组合。实际上Handler 自身已经提供了定时的功能。

private Handler handler = new Handler();

private Runnable myRunnable= new Runnable() {
public void run() {

if (run) {
handler.postDelayed(this, 1000);
count++;
}
tvCounter.setText("Count: " + count);

}
};

然后在其他地方调用

handler.post(myRunnable);

handler.post(myRunnable,time);

案例看：http://shaobin0604.javaeye.com/blog/515820

====================================================================

知识点总结补充：

很多初入Android或Java开发的新手对Thread、Looper、Handler和Message仍然比较迷惑，衍生的有HandlerThread、java.util.concurrent、Task、AsyncTask由于目前市面上的书籍等资料都没有谈到这些问题，今天就这一问题做更系统性的总结。我们创建的Service、Activity以及Broadcast均是一个主线程处理，这里我们可以理解为UI线程。但是在操作一些耗时操作时，比如I/O读写的大文件读写，数据库操作以及网络下载需要很长时间，为了不阻塞用户界面，出现ANR的响应提示窗口，这个时候我们可以考虑使用Thread线程来解决。

对于从事过J2ME开发的程序员来说Thread比较简单，直接匿名创建重写run方法，调用start方法执行即可。或者从Runnable接口继承，但对于Android平台来说UI控件都没有设计成为线程安全类型，所以需要引入一些同步的机制来使其刷新，这点Google在设计Android时倒是参考了下Win32的消息处理机制。

1. 对于线程中的刷新一个View为基类的界面，可以使用postInvalidate()方法在线程中来处理，其中还提供了一些重写方法比如postInvalidate(int left,int top,int right,int bottom) 来刷新一个矩形区域，以及延时执行，比如postInvalidateDelayed(long delayMilliseconds)或postInvalidateDelayed(long delayMilliseconds,int
left,int top,int right,int bottom) 方法，其中第一个参数为毫秒

2. 当然推荐的方法是通过一个Handler来处理这些，可以在一个线程的run方法中调用handler对象的 postMessage或sendMessage方法来实现，Android程序内部维护着一个消息队列，会轮训处理这些，如果你是Win32程序员可以很好理解这些消息处理，不过相对于Android来说没有提供 PreTranslateMessage这些干涉内部的方法。

3. Looper又是什么呢? ，其实Android中每一个Thread都跟着一个Looper，Looper可以帮助Thread维护一个消息队列，但是Looper和Handler没有什么关系，我们从开源的代码可以看到Android还提供了一个Thread继承类HanderThread可以帮助我们处理，在HandlerThread对象中可以通过getLooper方法获取一个Looper对象控制句柄，我们可以将其这个Looper对象映射到一个Handler中去来实现一个线程同步机制，Looper对象的执行需要初始化Looper.prepare方法就是昨天我们看到的问题，同时推出时还要释放资源，使用Looper.release方法。

4.Message 在Android是什么呢? 对于Android中Handler可以传递一些内容，通过Bundle对象可以封装String、Integer以及Blob二进制对象，我们通过在线程中使用Handler对象的sendEmptyMessage或sendMessage方法来传递一个Bundle对象到Handler处理器。对于Handler类提供了重写方法handleMessage(Message msg) 来判断，通过msg.what来区分每条信息。将Bundle解包来实现Handler类更新UI线程中的内容实现控件的刷新操作。相关的Handler对象有关消息发送sendXXXX相关方法如下，同时还有postXXXX相关方法，这些和Win32中的道理基本一致，一个为发送后直接返回，一个为处理后才返回
.

5. java.util.concurrent对象分析，对于过去从事Java开发的程序员不会对Concurrent对象感到陌生吧，他是JDK 1.5以后新增的重要特性作为掌上设备，我们不提倡使用该类，考虑到Android为我们已经设计好的Task机制，这里不做过多的赘述，相关原因参考下面的介绍:

6. 在Android中还提供了一种有别于线程的处理方式，就是Task以及AsyncTask，从开源代码中可以看到是针对Concurrent的封装，开发人员可以方便的处理这些异步任务。

摘录自：http://www.cnblogs.com/playing/archive/2011/03/24/1993583.html

一、Handler的定义:
   Handler主要接收子线程发送的数据, 并用此数据配合主线程更新UI，用来跟UI主线程交互用。比如可以用handler发送一个message，然后在handler的线程中来接收、处理该消息，以避免直接在UI主线程中处理事务导致影响UI主线程的其他处理工作，Android提供了Handler作为主线程和子线程的纽带；也可以将handler对象传给其他进程，以便在其他进程中通过handler给你发送事件；还可以通过handler的延时发送message，可以延时处理一些事务的处理。
通常情况下，当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程) ,主线程为管理界面中的UI控件，进行事件分发。如果此时需要一个耗时的操作，例如:联网读取数据，或者读取本地较大的一个文件的时候，你不能把这些操作放在主线程中，如果你放在主线程中的话，界面会出现假死现象,如果5秒钟还没有完成的话，会收到Android系统的一个错误提示"强制关闭".
这个时候我们需要把这些耗时的操作，放在一个子线程中,因为子线程涉及到UI更新，但是当子线程中有涉及到操作UI的操作时，就会对主线程产生危险，也就是说，更新UI只能在主线程中更新，在子线程中操作是危险的.这个时候，Handler就出现了来解决这个复杂的问题，由于Handler运行在主线程中(UI线程中)，它与子线程可以通过Message对象来传递数据，这个时候，Handler就承担着接受子线程传过来的(子线程用sedMessage()方法传递)Message对象，(里面包含数据),把这些消息放入主线程队列中，配合主线程进行更新UI。

二、Handler一些特点
       handler可以分发Message对象和Runnable对象到主线程中,每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程), 也就是说Handler对象初始化后，就默认与对它初始化的进程的消息队列绑定，因此可以利用Handler所包含的消息队列，制定一些操作的顺序。

三、Handler中分发消息的一些方法
       post(Runnable)
       postAtTime(Runnable,long)
       postDelayed(Runnable long)
           post类方法允许你排列一个Runnable对象到主线程队列中
       sendEmptyMessage(int)
       sendMessage(Message)
       sendMessageAtTime(Message,long)
       sendMessageDelayed(Message,long)
          sendMessage类方法, 允许你安排一个带数据的Message对象到队列中，等待更新.

四、应用实例：

  1，传递Message。用于接受子线程发送的数据,并用此数据配合主线程更新UI。

         在Android中，对于UI的操作通常需要放在主线程中进行操作。如果在子线程中有关于UI的操作，那么就需要把数据消息作为一个Message对象发送到消息队列中，然后，用Handler中的handlerMessge方法处理传过来的数据信息，并操作UI。类sendMessage(Message
msg)方法实现发送消息的操作。在初始化Handler对象时重写的handleMessage方法来接收Messgae并进行相关操作。

2，传递Runnable对象。用于通过Handler绑定的消息队列，安排不同操作的执行顺序。

Handler对象在进行初始化的时候，会默认的自动绑定消息队列。利用类post方法，可以将Runnable对象发送到消息队列中，按照队列的机制按顺序执行不同的Runnable对象中的run方法。

另外，Android的CPU分配的最小单元是线程，Handler一般是在某个线程里创建的，因而Handler和Thread就是相互绑定的，一一对应。而Runnable是一个接口，Thread是Runnable的子类。所以说，他俩都算一个进程。


视频教程中的例子：

1. public class HandlerActivity extends Activity {
2.
3.     //声明两个按钮控件
4.     private Button startButton = null;
5.     private Button endButton = null;
6.     @Override
7.     public void onCreate(Bundle savedInstanceState) {
8.         super.onCreate(savedInstanceState);
9.         setContentView(R.layout.main);
10.        //根据控件的ID得到代表控件的对象，并为这两个按钮设置相应的监听器
11.        startButton = (Button)findViewById(R.id.startButton);
12.        startButton.setOnClickListener(new StartButtonListener());
13.        endButton = (Button)findViewById(R.id.endButton);
14.        endButton.setOnClickListener(new EndButtonListener());
15.
16.    }
17.    class StartButtonListener implements OnClickListener{
18.
19.        @Override
20.        public void onClick(View v) {
21.            //调用Handler的post方法，将要执行的线程对象添加到队列当中
22.            handler.post(updateThread);
23.        }
24.
25.    }
26.
27.    class EndButtonListener implements OnClickListener{
28.
29.        @Override
30.        public void onClick(View v) {
31.            handler.removeCallbacks(updateThread);
32.        }
33.
34.    }
35.    //创建一个Handler对象
36.    Handler handler  = new Handler();
37.    //将要执行的操作写在线程对象的run方法当中
38.    Runnable updateThread =  new Runnable(){
39.
40.        @Override
41.        public void run() {
42.            System.out.println("UpdateThread");
43.            //在run方法内部，执行postDelayed或者是post方法
44.            handler.postDelayed(updateThread, 3000);
45.        }
46.
47.    };
48.}

   程序的运行结果就是每隔3秒钟，就会在控制台打印一行UpdateTread。这是因为实现了Runnable接口的updateThread对象进入了空的消息队列即被立即执行run方法，而在run方法的内部，又在3000ms之后将其再次发送进入消息队列中。
  3，Handler和多线程
   post方法虽然发送的是一个实现了Runnable接口的类对象，但是它并非创建了一个新线程，而是执行了该对象中的run方法。也就是说，整个run中的操作和主线程处于同一个线程。
   这样对于那些简单的操作，似乎并不会影响。但是对于耗时较长的操作，就会出现“假死”。为了解决这个问题，就需要使得handler绑定到一个新开启线程的消息队列上，在这个处于另外线程的上的消息队列中处理传过来的Runnable对象和消息。

1. public class HandlerTest2 extends Activity {
2.
3.     @Override
4.     protected void onCreate(Bundle savedInstanceState) {
5.         // TODO Auto-generated method stub
6.     super.onCreate(savedInstanceState);
7.     setContentView(R.layout.main);
8.     //打印了当前线程的ID

9.     System.out.println("Activity-->" + Thread.currentThread().getId());
10.    //生成一个HandlerThread对象
11.    HandlerThread handlerThread = new HandlerThread("handler_thread");
12.    //在使用HandlerThread的getLooper()方法之前，必须先调用该类的start()，同时开启一个新线程;

13.    handlerThread.start();
14.    //将由HandlerThread获取的Looper传递给Handler对象，即由处于另外线程的Looper代替handler初始化时默认绑定的消息队列来处理消息。
15.     // HandlerThread顾名思义就是可以处理消息循环的线程，它是一个拥有Looper的线程
16.，可以处理消息循环；
其实与其说Handler和一个线程绑定，倒不如说Handler和Looper是
17.一一对应的。
18.    MyHandler myHandler = new MyHandler(handlerThread.getLooper());
19.    Message msg = myHandler.obtainMessage();
20.    //将msg发送到目标对象，所谓的目标对象，就是生成该msg对象的handler对象
21.    Bundle b = new Bundle();
22.    b.putInt("age", 20);
23.    b.putString("name", "Jhon");
24.    msg.setData(b);
25.    msg.sendToTarget(); //将msg发送到myHandler
26.    }
27.
28.    //定义类
29.    class MyHandler extends Handler{
30.    public MyHandler(){
31.
32.    }
33.
34.    public MyHandler(Looper looper){
35.        super(looper);
36.    }
37.    @Override
38.    public void handleMessage(Message msg) {
39.        Bundle b = msg.getData();
40.        int age = b.getInt("age");
41.        String name = b.getString("name");
42.        System.out.println("age is " + age + ", name is" + name);
43.        System.out.println("Handler--->" + Thread.currentThread().getId());
44.        System.out.println("handlerMessage");
45.        }
46.    }
47.}

   这样，当使用sendMessage方法传递消息或者使用post方法传递Runnable对象时，就会把它们传递到与handler对象绑定的处于另外一个线程的消息队列中，它们将在另外的消息队列中被处理。而主线程还会在发送操作完成时候继续进行，不会影响当前的操作。
这里需要注意，这里用到的多线程并非由Runnable对象开启的，而是ThreadHandler对象开启的。Runnable对象只是作为一个封装了操作的对象被传递，并未产生新线程。
另外再强调一遍，在UI线程（主线程）中：
   mHandler=new Handler();
    mHandler.post(newRunnable(){
    voidrun(){
      //执行代码..
    }
   });
   这个线程其实是在UI线程之内运行的，并没有新建线程。

   常见的新建线程的方法是：
   Thread thread = new Thread();
   thread.start();

   HandlerThread thread = new HandlerThread("string");
   thread.start();

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签： Android 线程安全

相关文章推荐

新的分享

章节导航