Message
Message，消息，用于在线程之间传递数据。Message 对象可以通过 new 关键字来获得，但为了节省资源，通常使用 Message.obtain() 方法或 Handler.obtainMessage() 方法来从消息池中获得空消息对象。下面是它的属性：
- arg1： 用来存放 int 型数据；
- arg2： 用来存放 int 型数据；
- obj： 用来存放 Object 数据(即存放对象)；
- what： 用于指定用户自定义的消息代码，便于主线程接收后，根据不同的消息代码执行不同的操作；
- setData(Bundle)： 传送复杂的数据。
Handler
- Handler，处理者，负责发送消息和处理消息。发送消息的方法有 <code>post</code> 类方法和 <code>sendMessage</code> 类方法；发出的消息经过辗转最终会传递到 Handler 的 <code>handleMessage()</code> 方法中，在该方法中对接收到的消息进行处理；
- 发送消息的方法：<code>post</code> 类的方法允许你将被消息队列调用的 Runnable 对象 放入队列中；<code>sendMessage</code> 类的方法允许你将包含一组将被 <code>handleMessage(Message)</code> 方法处理的 **Message 对象 **放入消息队列中 （需要重写 Handler 的 <code>handleMessage(Message)</code> 方法）：
- handleMessage(Message)： 在主线程中，创建 Handler 对象时，重写此方法；
- sendEmptyMessage(int what)： 发送空消息；
- sendMessage(Message)： 立即发送消息；
- post(Runnable)： 将线程添加到消息序列中。
MeessageQueue
- MeessageQueue，消息队列，用来存放所有通过 Handler 发送的消息，这部分消息会一直存在消息队列中，等待被处理，（按照 FIFO (先进先出) 的规则执行）；
- 一个线程中只会有一个 MessageQueue 对象。
Looper
Looper，消息泵，是每个线程中 MessageQueue 的管家，调用 Looper 的 <code>loop()</code> 方法后，就会进入到一个无限循环中，每当发现 MessageQueue 中存在一条消息，Looper 就会将它取出，并传递到 Handler 的 <code>handleMessage()</code> 方法中。一个线程中只会有一个 Looper 对象。
四者关系
如图，Handler 是寄信人，负责把 Message 放到 MessageQueue 里面去；Message 是信件；MessageQueue 是邮筒，先进来的信件会先被取出；Looper 是邮差，负责管理 Message(信件)，当 MessageQueue(邮筒) 里有 Message(信件) 时，就将其取出，然后交给 Handler(收信人) 处理；其中，Handler 既是寄信人，又是收信人。
- 一个线程中只能有一个 Looper 对象和 MessageQueue 对象，但是可以有多个 Handler 和 Message；多个 Handler 可以共享一个 Looper 和 MessageQueue，但一个 Handler 只能有一个 MessageQueue；Message 被存放在 MessageQueue 中。
- Looper 对象用来为一个线程开启一个消息循环，从而操作 MessageQueue；
默认情况下，Android 创建的线程没有开启消息循环，但是系统会自动为主线程创建 Looper 对象，开启消息循环；如果在子线程想要创建 Handler 对象，需要执行执行 Looper.prepare() 方法，然后创建 Handler 对象，最后执行 Looper.loop() 方法。
Looper.prepare();
Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
}
}
Looper.loop();
- 四者的结合使用实现线程间的通信。
线程间的通信
WorkerThread 向 MainThread 发送消息
- activity_main.xml：
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:padding="16dp"
tools:context="MainActivity">
<ImageView
android:id="@+id/iv"
android:layout_width="match_parent"
android:layout_height="0dp"
android:layout_weight="1" />
<Button
android:id="@+id/btn"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:onClick="download"
android:text="下载图片" />
</LinearLayout>
2. MainActivity.java：
public class MainActivity extends AppCompatActivity {
private ImageView iv;
// 创建一个 Handler 对象
private Handler handler = new Handler() {
// 必须重写 handleMessage(Message msg) 方法
@Override
public void handleMessage(Message msg) {
// 根据接收到的不同消息代码进行不同的操作
switch (msg.what) {
case 0:
Bitmap bitmap = (Bitmap) msg.obj;
iv.setImageBitmap(bitmap);
Bundle data = msg.getData();
int length = data.getStringArray("key").length;
Toast.makeText(MainActivity.this, "数组长度为：" + length, Toast.LENGTH_SHORT).show();
break;
default:
break;
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// 初始化布局中的 ImageView
iv = (ImageView) findViewById(R.id.iv);
}
// 设置按钮的点击事件
public void download(View view) {
String url = "http://www.bz55.com/uploads/allimg/150824/139-150R41H233.jpg";
// 创建一个线程，并传入网址
new Thread(new DownloadRunnable(url)).start();
}
// 创建一个内部类，用于下载图片(耗时操作)
public class DownloadRunnable implements Runnable {
private String urlAddress;
public DownloadRunnable(String urlAddress) {
this.urlAddress = urlAddress;
}
// 声明一个 HttpURLConnection 对象
HttpURLConnection conn;
@Override
public void run() {
try {
// 创建一个 URL 对象，该对象需要传入一个 String 类型的参数，一般为网址
URL url = new URL(urlAddress);
// 实例化 HttpURLConnection 对象
conn = (HttpURLConnection) url.openConnection();
// 设置请求方式
conn.setRequestMethod("GET");
// 设置与服务器建立连接的超时时间
conn.setConnectTimeout(5000);
// 设置建立连接后服务器没有返回数据的超时时间
conn.setReadTimeout(8000);
// 设置是否允许读取服务器返回的数据，默认为 true
conn.setDoInput(true);
// 设置是否允许向服务器写入数据，默认为 false
// conn.setDoOutput(true); // 本例中所用服务器不允许我们对其写入数据
// 建立连接
conn.connect();
// 获取状态码
int responseCode = conn.getResponseCode();
Log.v("responseCode", responseCode + "");
if (responseCode == 200) { // responseCode 为 200 时说明连接成功
// 获取输入流，得到服务器返回的数据
InputStream in = conn.getInputStream();
Bitmap bitmap = BitmapFactory.decodeStream(in);
// 第一种方式
// 获得 Message 对象
Message msg = Message.obtain();
// 设置自定义消息代码
msg.what = 0;
// 将下载完成的图片放入 Message 对象中
msg.obj = bitmap;
// 传递复杂数据
Bundle data = new Bundle();
data.putStringArray("key", new String[]{"str1", "str2", "str3"});
msg.setData(data);
// 发送消息至 MessageQueue 中
handler.sendMessage(msg);
// 第二种方式
// 获得一个 Message 对象，调用 Message 的 obtain(Handler h) 方法获得
// Message msg = Message.obtain(handler);
// msg.what = 0;
// msg.obj = bitmap;
// 发送消息至 MessageQueue 中
// msg.sendToTarget();
// 第三种方式
// 获得一个 Message 对象，调用 Message 的 obtain(Handler h，int what) 方法获得
// Message msg = Message.obtain(handler, 0);
// msg.obj = bitmap;
// 发送消息至 MessageQueue 中
// msg.sendToTarget();
// 第四种方式
// 获得一个 Message 对象，调用 Message 的 obtain(Handler h，int what, Object obj) 方法获得
// Message msg = Message.obtain(handler, 0, bitmap);
// 发送消息至 MessageQueue 中
// msg.sendToTarget();
// 第五种方式
// 获得一个 Message 对象，
// 调用 Message 的 obtain(Handler h，int what, int arg1, int arg2, Object obj) 方法获得
// Message msg = Message.obtain(handler, 0, 0, 0, bitmap);
// 发送消息至 MessageQueue 中
// msg.sendToTarget();
}
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 关闭连接
conn.disconnect();
}
}
}
}
3. 声明联网权限，AndroidManifest.xml：
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="net.monkeychan.handlertest01">
<uses-permission android:name="android.permission.INTERNET"/>
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
4. 效果演示：
- 运行程序：
- 点击按钮，下载图片：
总结： WorkerThread 向 MainThread 发送消息的步骤：
- 在 MainThread 中：
- 创建一个 Handler 对象，并重写 handleMessage(Message) 方法，在此方法内根据接收到的消息进行操作；
- 在 WorkerThread 中：
- 获得 Message 对象，并往 Message 对象里存放需要发送的数据；
- 使用 Handler 对象的 sendMessage 类方法发送 Message 对象至 MessageQueue 中； 或使用 Message 对象的 sendToTarget() 方法发送 Message 对象至 MessageQueue 中；或使用 post 类方法发送 Runnable 对象至 MessageQueue 中。
MainThread 向 WorkerThread 发送消息
1. activity_main.xml：
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:padding="16dp"
tools:context=".MainActivity">
<Button
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="MainThread 给 WorkerThread 发送消息"
android:onClick="send"/>
</LinearLayout>
2. MainActivity.java：
public class MainActivity extends AppCompatActivity {
// 声明一个 Handler 对象
private Handler handler;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// 启动线程
new Thread(new ChildThread()).start();
}
public void send(View view) {
// 向 MessageQueue 发送一个空消息
handler.sendEmptyMessage(0);
}
public class ChildThread implements Runnable {
@Override
public void run() {
// 1. 准备一个 Looper
Looper.prepare();
// 2. 实例化 Handler 对象
handler = new Handler() {
@Override
public void handleMessage(Message msg) {
Toast.makeText(MainActivity.this,
"WorkerThread 收到了来自 MainThread 的消息", Toast.LENGTH_SHORT).show();
}
};
// 3. 让 Looper 循环取出 MessageQueue 中的消息
Looper.loop();
}
}
}
3. 效果演示：
点击按钮：
总结：MainThread 向 WorkerThread 发送消息的步骤
步骤跟 WorkerThread 向 MainThread 发送消息的步骤 一样，只不过消息的发送方和接收方对调，并且在 WorkerThread 实例化 Handler 对象之前准备一个 Looper，并在实例化 Handler 对象之后然 Looper 循环：
- 在 MainThread 中：
- 声明一个 Handler 对象，并使用 Handler 对象的 sendMessage 类方法发送 Message 对象至 MessageQueue 中； 或使用 Message 对象的 sendToTarget() 方法发送 Message 对象至 MessageQueue 中；或使用 post 类方法发送 Runnable 对象至 MessageQueue 中
- 在 WorkerThread 中：
- 准备一个 Looper；
- 在 WorkerThread中实例化在 MainThread 中声明的 Handler 对象，并重写 handleMessage(Message msg) 方法，在此方法内根据接收到的消息进行操作；
- 在 WorkerThread 让 Looper 循环。
参考资料：
