• Android组件通信——消息机制（二十六）

    1. 消息机制

    1.1 知识点

    （1）掌握Message、Handler、Looper类的使用以及消息的传递；

    （2）可以通过消息机制动态取得信息；

    1.2 具体内容

    对于android的消息机制，我们主要要使用Java中线程的一些知识：

    线程：线程是进程一个细的划分，一个进程可以存在多个线程。Java中实现多线程的手段有两种：

           ·继承Thread类

           ·实现Runnable接口

    在开发中，使用第二种方式实现多线程是优先选择的，主要继承Thread实现的多线程有一下两个问题：

           ·Java单继承的局限

           ·使用Runnable可以实现数据的共享

    但是使用第二种方式实现的多线程，在线程启动的时候也必须使用Thread进行线程的启动。

    主线程一般在android中成为UI线程，就是一个界面显示，那么这种就是主线程，而子线程就是利用那些实现了Runnable接口的线程的操作类。

    对于Message和Handler类的操作，都会比较不太理解，现在完成一个更新的操作（子线程向主线程发送消息）。

    1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    2.     xmlns:tools="http://schemas.android.com/tools"
    3.     android:layout_width="match_parent"
    4.     android:layout_height="match_parent"
    5.     android:orientation="vertical">
    6.     <TextView
    7.         android:id="@+id/info"
    8.         android:layout_width="wrap_content"
    9.         android:layout_height="wrap_content"/>
    10. </LinearLayout>
    11.

    下面就是希望完成文本自动更新的操作，使用任务管理器完成（TimerTask）。

    1. package com.example.messageproject;
    2.  
    3. import java.util.Timer;
    4. import java.util.TimerTask;
    5.  
    6. import android.app.Activity;
    7. import android.os.Bundle;
    8. import android.os.Handler;
    9. import android.os.Message;
    10. import android.widget.TextView;
    11.  
    12. public class MainActivity extends Activity {
    13. 	private TextView info = null;
    14. 	private static int count = 0;
    15. 	public static final int SET = 1;//定义消息的标记
    16. 	private Handler myHandler = new Handler(){
    17. 		@Override
    18. 		public void handleMessage(Message msg) {
    19. 			switch(msg.what){
    20. 			case SET:
    21. 				MainActivity.this.info.setText("Wanczy-" + count++);
    22. 				break;
    23. 			}
    24. 		}
    25. 	};
    26. 	@Override
    27. 	protected void onCreate(Bundle savedInstanceState) {
    28. 		super.onCreate(savedInstanceState);
    29. 		super.setContentView(R.layout.activity_main);
    30. 		this.info = (TextView) super.findViewById(R.id.info);
    31. 		Timer timer = new Timer();//定义调度器
    32. 		timer.schedule(new MyTimerTask(), 0, 1000);//启动定时调度
    33. 	}
    34. 	/**
    35. 	 * 定义了一个子线程
    36. 	 * @author Administrator
    37. 	 *
    38. 	 */
    39. 	private class MyTimerTask extends TimerTask{
    40. 		@Override
    41. 		public void run() {
    42. 			Message msg = new Message();//定义消息
    43. 			msg.what = SET;//定义操作标记
    44. 			MainActivity.this.myHandler.sendMessage(msg);//发送消息
    45. 		}
    46. 		
    47. 	}
    48. }
    49.

    对于这个程序而言，发现是在Handler中处理组件（TextView）的，为什么不在子线程中完成呢？

    01-26 08:24:47.374: ERROR/AndroidRuntime(3533): android.view.ViewRoot$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

    这个错误指：子线程不能更新主线程中各个组件的状态。表示只要是子线程就无法去更新组件，那么现在只能采用之前的方法，在子线程中返回要操作的信息，而后主线程中利用Handler处理这些消息，从而实现线程的操作。

    在正常的开发之中，不需要开发者去手动处理Looper，Activity类中会自动的启动好。

    范例：Looper进行通讯操作：

    1. package com.example.messageproject;
    2.  
    3. import android.app.Activity;
    4. import android.os.Bundle;
    5. import android.os.Handler;
    6. import android.os.Looper;
    7. import android.os.Message;
    8. import android.view.View;
    9. import android.view.View.OnClickListener;
    10. import android.widget.Button;
    11. import android.widget.TextView;
    12.  
    13. public class MainActivity extends Activity {
    14. 	private TextView info = null;
    15. 	private Button but = null;
    16. 	public static final int SET = 1;//定义消息的标记
    17. 	@Override
    18. 	protected void onCreate(Bundle savedInstanceState) {
    19. 		super.onCreate(savedInstanceState);
    20. 		super.setContentView(R.layout.activity_main);
    21. 		this.info = (TextView) super.findViewById(R.id.info);
    22. 		this.but = (Button) super.findViewById(R.id.but);
    23. 		this.but.setOnClickListener(new OnClickListenerImpl());
    24. 	} 
    25. 	private class OnClickListenerImpl implements OnClickListener{
    26. 		@Override
    27. 		public void onClick(View v) {
    28. 			Looper looper = Looper.myLooper();//取得Looper对象
    29. 			MyHandler handler = new MyHandler(looper);
    30. 			handler.removeMessages(0);//清空队列中所有消息
    31. 			String data = "厦门万策智业科技有限公司(Wanczy)";
    32. 			Message msg = handler.obtainMessage(SET, data);
    33. 			handler.sendMessage(msg);//发送消息
    34. 		}
    35. 		
    36. 	}
    37. 	private class MyHandler extends Handler{
    38. 		public MyHandler(Looper looper){//用来接收Looper
    39. 			super(looper);
    40. 		}
    41. 		@Override
    42. 		public void handleMessage(Message msg) {
    43. 			switch(msg.what){
    44. 			case SET:
    45. 				MainActivity.this.info.setText(msg.obj.toString());//取得消息的内容
    46. 				break;
    47. 			}
    48. 		}
    49. 		
    50. 	}
    51. }
    52.

    在程序中，去掉Looper之后，发现程序的运行也是一样的，说明Activity程序会自动启动Looper，很多时候不需要开发者去定义Looper。现在我们程序里面这3个关键类都有使用了，对于操作而言，以后就只需要用到Message 和Handler，下面我们来完成一个子线程与主线程的数据交互。

    对于子线程，不能更新组件，所以接受到消息之后也只能进行后台的输出。

    1. "http://schemas.android.com/apk/res/android"
    2.     xmlns:tools="http://schemas.android.com/tools"
    3.     android:layout_width="match_parent"
    4.     android:layout_height="match_parent"
    5.     android:orientation="vertical">
    6.     
    7.         android:id="@+id/info"
    8.         android:layout_width="match_parent"
    9.         android:layout_height="wrap_content"/>
    10.     
    11.         android:id="@+id/but"
    12.         android:layout_width="match_parent"
    13.         android:layout_height="wrap_content"
    14.         android:text="交互"/>
    16.  
    1. package com.example.messageproject;
    2.  
    3. import android.app.Activity;
    4. import android.os.Bundle;
    5. import android.os.Handler;
    6. import android.os.Looper;
    7. import android.os.Message;
    8. import android.view.View;
    9. import android.view.View.OnClickListener;
    10. import android.widget.Button;
    11. import android.widget.TextView;
    12. public class MainActivity extends Activity {
    13. 	public static final int SETMAIN = 1; 			// 设置一个what标记
    14. 	public static final int SETCHILD = 2; 			// 设置一个what标记
    15. 	private Handler mainHandler, childHandler;		// 定义Handler对象
    16. 	private TextView msg;					// 文本显示组件
    17. 	private Button but;	
    18. 	class ChildThread implements Runnable {			// 子线程类
    19. 		@Override
    20. 		public void run() {
    21. 			Looper.prepare(); 				// 初始化Looper
    22. 			MainActivity.this.childHandler = new Handler() {
    23. 				public void handleMessage(Message msg) {
    24. 					switch (msg.what) { 	// 判断what操作
    25. 					case SETCHILD: 		// 主线程发送给子线程的信息
    26. 					System.out.println("*** Main Child Message : "
    27. 						+ msg.obj);	// 打印消息
    28. 						Message toMain = MainActivity.this.mainHandler.obtainMessage(); 	// 创建Message
    29. 						toMain.obj = "\n\n[B] 这是子线程发给主线程的信息："; // 设置显示文字
    30. 						toMain.what = SETMAIN; //设置主线程操作的状态码
    31. 					MainActivity.this.mainHandler.sendMessage(toMain); 					break;
    32. 					}
    33. 				}
    34. 			};
    35. 			Looper.loop();			// 启动该线程的消息队列
    36. 		}
    37. 	}
    38. 	@Override
    39. 	public void onCreate(Bundle savedInstanceState) {
    40. 		super.onCreate(savedInstanceState);
    41. 		super.setContentView(R.layout.activity_main); 		// 调用布局文件
    42. 		this.msg = (TextView) super.findViewById(R.id.info); 	// 取得组件
    43. 		this.but = (Button) super.findViewById(R.id.but); 	// 取得按钮
    44. 		this.mainHandler = new Handler() { 		// 主线程的Handler对象
    45. 			public void handleMessage(Message msg) {	// 消息处理
    46. 				switch (msg.what) { 	// 判断Message类型
    47. 				case SETMAIN: 		// 设置主线程的操作类
    48. 					MainActivity.this.msg.setText("主线程接收数据："
    49. 						+ msg.obj.toString()); 	// 设置文本内容
    50. 					break;
    51. 				}
    52. 			}
    53. 		};
    54. 		new Thread(new ChildThread(), "Child Thread").start(); // 启动子线程
    55. 		this.but.setOnClickListener(new OnClickListenerImpl()) ; 	// 单击事件操作
    56. 	}
    57. 	private class OnClickListenerImpl implements OnClickListener {
    58. 		@Override
    59. 		public void onClick(View view) {
    60. 			if (MainActivity.this.childHandler != null) { 	// 已实例化子线程Handler
    61. 				Message childMsg = MainActivity.this.childHandler
    62. 					.obtainMessage(); 		// 创建一个消息
    63. 				childMsg.obj = MainActivity.this.mainHandler.getLooper()
    64. 					.getThread().getName()+ " --> Hello MLDN .";// 设置消息内容
    65. 				childMsg.what = SETCHILD; 	// 操作码
    66. 				MainActivity.this.childHandler.sendMessage(childMsg); // 向子线程发送
    67. 			}
    68. 		}
    69. 	}
    70. 	@Override
    71. 	protected void onDestroy() {
    72. 		super.onDestroy();
    73. 		MainActivity.this.childHandler.getLooper().quit(); 	// 结束队列
    74. 	}
    75.  
    76. }
    77.

    范例：时钟显示

    1. "http://schemas.android.com/apk/res/android"
    2.     xmlns:tools="http://schemas.android.com/tools"
    3.     android:layout_width="match_parent"
    4.     android:layout_height="match_parent"
    5.     android:orientation="vertical">
    6.     
    7.         android:id="@+id/myAnalogClock"
    8.         android:layout_width="match_parent"
    9.         android:layout_height="wrap_content"
    10.         />
    11.     
    12.         android:id="@+id/info"
    13.         android:layout_width="match_parent"
    14.         android:layout_height="wrap_content"/>
    16.  
    1. package com.example.messageproject;
    2.  
    3. import java.text.SimpleDateFormat;
    4. import java.util.Date;
    5.  
    6. import android.app.Activity;
    7. import android.os.Bundle;
    8. import android.os.Handler;
    9. import android.os.Message;
    10. import android.widget.TextView;
    11.  
    12. public class MainActivity extends Activity {
    13. 	private TextView info = null;
    14. 	public static final int SET = 1;
    15. 	private Handler myHandler = new Handler(){
    16. 		@Override
    17. 		public void handleMessage(Message msg) {
    18. 			switch (msg.what){
    19. 			case SET:
    20. 				MainActivity.this.info.setText("当前时间为："+msg.obj.toString());
    21. 				break;
    22. 			}
    23. 		}
    24. 	};
    25. 	protected void onCreate(Bundle savedInstanceState) {
    26. 		super.onCreate(savedInstanceState);
    27. 		super.setContentView(R.layout.activity_main);
    28. 		this.info = (TextView) super.findViewById(R.id.info);
    29. 		new Thread(new ChildThread()).start();//启动子线程
    30. 	} 
    31. 	private class ChildThread implements Runnable{
    32. 		public void run(){
    33. 			while(true){
    34. 				Message msg = MainActivity.this.myHandler.obtainMessage();
    35. 				msg.what = SET;
    36. 				msg.obj = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
    37. 				MainActivity.this.myHandler.sendMessage(msg);//发送消息
    38. 			}
    39. 		}
    40. 	}
    41. }
    42. package com.example.messageproject;
    43.  
    44. import java.text.SimpleDateFormat;
    45. import java.util.Date;
    46.  
    47. import android.app.Activity;
    48. import android.os.Bundle;
    49. import android.os.Handler;
    50. import android.os.Message;
    51. import android.widget.TextView;
    52.  
    53. public class MainActivity extends Activity {
    54. 	private TextView info = null;
    55. 	public static final int SET = 1;
    56. 	private Handler myHandler = new Handler(){
    57.  
    58. 		@Override
    59. 		public void handleMessage(Message msg) {
    60. 			switch (msg.what){
    61. 			case SET:
    62. 				MainActivity.this.info.setText("当前时间为："+msg.obj.toString());
    63. 				break;
    64. 			}
    65. 		}
    66. 	};
    67. 	protected void onCreate(Bundle savedInstanceState) {
    68. 		super.onCreate(savedInstanceState);
    69. 		super.setContentView(R.layout.activity_main);
    70. 		this.info = (TextView) super.findViewById(R.id.info);
    71. 		new Thread().start();//启动子线程
    72. 	} 
    73. 	private class ChildThread implements Runnable{
    74. 		public void run(){
    75. 			while(true){
    76. 				Message msg = MainActivity.this.myHandler.obtainMessage();
    77. 				msg.what = SET;
    78. 				msg.obj = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
    79. 				MainActivity.this.myHandler.sendMessage(msg);//发送消息
    80. 			}
    81. 		}
    82. 	}
    83. }
    84.

    1.3 小结

    （1）在Android之中子线程不能直接对主线程的组件进行更新；

  • 相关阅读:
    OpenHarmony应用开发【01】
    金字塔的思维--思维的格式化与体系化
    [题]跳房子 #单调队列优化(伪)
    信息爆炸！78天闭门深造千页SpringCloud，再战京东
    每天五分钟机器学习：神经网络和支持向量机的基础——感知机模型
    FPGA 学习笔记：Vivado 工程管理技巧
    传感器数据采集：采样定理（奈奎斯特定理）
    前端vue中箭头函数省略return的写法之详细讲解
    LabVIEW使用视觉采集软件从GigE视觉相机进行采集 1
    [数据结构]链表OJ--环形链表判断是否有环(快慢指针法)
  • 原文地址：https://blog.csdn.net/weixin_41830242/article/details/133817988