android中handler用法总结

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

48. }

1. public class HandlerTest2 extends Activity {
2. @Override
3. protected void onCreate(Bundle savedInstanceState) {
4. // TODO Auto-generated method stub
5. super.onCreate(savedInstanceState);
6. setContentView(R.layout.main);
7. //打印了当前线程的ID
8. System.out.println("Activity-->" + Thread.currentThread().getId());
9. 10.     //生成一个HandlerThread对象
10. 11.     HandlerThread handlerThread = new HandlerThread("handler_thread");
11. 12.     //在使用HandlerThread的getLooper()方法之前，必须先调用该类的start()，同时开启一个新线程;
12. 13.     handlerThread.start();
13. 14.     //将由HandlerThread获取的Looper传递给Handler对象，即由处于另外线程的Looper代替handler初始化时默认绑定的消息队列来处理消息。
14. 15.      // HandlerThread顾名思义就是可以处理消息循环的线程，它是一个拥有Looper的线程

16. ，可以处理消息循环；  其实与其说Handler和一个线程绑定，倒不如说Handler和Looper是

17. 一一对应的。

1. 18.     MyHandler myHandler = new MyHandler(handlerThread.getLooper());
2. 19.     Message msg = myHandler.obtainMessage();
3. 20.     //将msg发送到目标对象，所谓的目标对象，就是生成该msg对象的handler对象
4. 21.     Bundle b = new Bundle();
5. 22.     b.putInt("age", 20);
6. 23.     b.putString("name", "Jhon");
7. 24.     msg.setData(b);
8. 25.     msg.sendToTarget();  //将msg发送到myHandler
9. 26.     }
10. 27.
11. 28.     //定义类
12. 29.     class MyHandler extends Handler{
13. 30.     public MyHandler(){
14. 31.
15. 32.     }
16. 33.
17. 34.     public MyHandler(Looper looper){
18. 35.         super(looper);
19. 36.     }
20. 37.     @Override
21. 38.     public void handleMessage(Message msg) {
22. 39.         Bundle b = msg.getData();
23. 40.         int age = b.getInt("age");
24. 41.         String name = b.getString("name");
25. 42.         System.out.println("age is " + age + ", name is" + name);
26. 43.         System.out.println("Handler--->" + Thread.currentThread().getId());
27. 44.         System.out.println("handlerMessage");
28. 45.         }
29. 46.     }

47. }