Android - Handler、Message、Messag

2016-05-10 本文已影响274人 AshengTan

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 循环。

参考资料：