android之handle

　　Android中异步消息处理主要由四个部分组成，Message、handler、messageQueue和looper。

1、message

　　message是线程之间传递的消息，他可以在内部携带少量的信息，用于在不同线程之间交换数据。除了使用Message中的what字段、还可以使用arg1和arg2字段携带一些整型数据，使用obj字段携带一个Object对象。

2、Handler

　　Handler顾名思义是处理者意思，它主要用于发送和处理消息。发送消息一般使用handler的sendMessage()方法，而发出的消息经过一系列的辗转处理后，最终会传递到handler的handleMessage()方法中。

3、MessageQueue

　　MessageQueue是消息列队的意思，它主要用于存放所有通过Handler发送的消息。这部分消息会一直存放于消息列队中，等待被处理，每个线程中只会有一个MessageQueue对象。

4、Looper

　　Looper是每个线程中的MessageQueue的管家，调用Looper的loop()方法后，就好进入到一个无限循环当中，当然每当发现MessageQueue中存在一条消息，就会将它取出，并传递到Handler的handleMessage()方法中。每个线程中也只会有一个Looper对象。

异步消息流程梳理：

　　1、主线程上创建一个Handler对象，并重写handleMessage()方法。

　　2、当子线程中需要UI操作，创建Message对象，并通过Handler将这条信息发送出去。

　　3、消息被添加到MessageQueue的队列中等待被处理、Looper会一直尝试从MessageQueue中取出待处理消息、分发会Handler的handleMessage()方法中。

　　**因为handler是在主线程中创建，所以handleMessage()方法中代码也会在主线程中运行，于是我们可以安心对UI操作了。

整个异步消息处理机制的流程示意图：

运用handler改写昨天的代码：

MainActivity.java

package com.example.threadasynctask;

import android.app.Activity;

import android.os.Bundle;

import android.os.Handler;

import android.os.Message;

import android.util.Log;

import android.view.View;

import android.view.View.OnClickListener;

import android.widget.Button;

import android.widget.ProgressBar;

import android.widget.TextView;

import android.widget.Toast;

public class MainActivity extends Activity {

    private Button btn;

    private TextView tv;

    private ProgressBar progressBar;

    private Runnable doInBackground1;

    private Runnable doInBackground2;

    private String str;

    private int n;

    //1.跟着主线程走，可以碰UI

    //2.能够接受子线程发送的消息(Message)

    //        子线程类本身不可以发信息

    private Handler handler;

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        Log.i("UI_MainThread","主线程id:"+Thread.currentThread().getId());

        tv =(TextView)findViewById(R.id.tv_start);

        btn =(Button)findViewById(R.id.btn_start);

        progressBar = (ProgressBar)findViewById(R.id.progressBar1);

        btn.setOnClickListener(new OnClickListener() {

            @Override

            public void onClick(View v) {

                //AsyncTask异步信息更新

            /*    MyTask mt = new MyTask(tv,progressBar);

                mt.execute(1000);//里面的参数是传给doInBackground*/

                Thread t1 = new Thread(doInBackground1);

                t1.start();

                Thread t2 = new Thread(doInBackground2);

                t2.start();

            }

        });

        handler = new Handler(){

            //1.消息msg来自于子线程

            //2.消息可以多个，采用msg.what识别

            //3.处理消息，一般就会更新UI

            //4.此方法可以参考onPostExecute

            @Override

            public void handleMessage(Message msg) {

                super.handleMessage(msg);

                int msgwhat = msg.what;

                Log.i("handler","已经收到消息，消息what："+msgwhat+",id:"+Thread.currentThread().getId());

                if (msgwhat==1){

                    //土司

                    Toast.makeText(MainActivity.this, "开始下载", Toast.LENGTH_SHORT).show();

                }

                if (msgwhat==2){

                    //更新helloworld

                    tv.setText("下载完成"+str);

                }

            }

        };

        //子线程代码1

        doInBackground1 = new Runnable() {

            @Override

            public void run() {

                Log.i("sub_Thread","子线程1启动,id:"+Thread.currentThread().getId());

                try {

                    Thread.sleep(1000);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                //1.访问数据库或者互联网,不在UI进程，所以不卡

                Message msg = new Message();

                //对消息一个识别号，便于handler能够识别

                msg.what = 1;

                handler.sendMessage(msg);

                Log.i("sub_Thread","子线程1已经发送消息给handler");

            }

        };

        //子线程代码2

        doInBackground2 = new Runnable() {

            @Override

            public void run() {

                Log.i("sub_Thread","子线程2启动,id:"+Thread.currentThread().getId());

                try {

                    Thread.sleep(100);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                Message msg = new Message();

                //对消息一个识别号，便于handler能够识别

                msg.what = 2;

                //访问互联网，下载最新的，更新data,但不碰界面

                handler.sendMessage(msg);

            }

        };

    }

}

handler之内存泄露

内存泄漏也称作“存储渗漏”，用动态存储分配函数动态开辟的空间，在使用完毕后未释放，结果导致一直占据该内存单元。直到程序结束。（其实说白了就是该内存空间使用完毕之后未回收）即所谓内存泄漏。

内存泄漏形象的比喻是“操作系统可提供给所有进程的存储空间正在被某个进程榨干”，最终结果是程序运行时间越长，占用存储空间越来越多，最终用尽全部存储空间，整个系统崩溃。所以“内存泄漏”是从操作系统的角度来看的。这里的存储空间并不是指物理内存，而是指虚拟内存大小，这个虚拟内存大小取决于磁盘交换区设定的大小。由程序申请的一块内存，如果没有任何一个指针指向它，那么这块内存就泄漏了。

Handler也是造成内存泄露的一个重要的源头，主要Handler属于TLS(Thread Local Storage)变量,生命周期和Activity是不一致的

，Handler引用Activity会存在内存泄露。

Handler 的生命周期与Activity 不一致

当Android应用启动的时候，会先创建一个UI主线程的Looper对象，Looper实现了一个简单的消息队列，一个一个的处理里面的Message对象。主线程Looper对象在整个应用生命周期中存在。
当在主线程中初始化Handler时，该Handler和Looper的消息队列关联（没有关联会报错的）。发送到消息队列的Message会引用发送该消息的Handler对象，这样系统可以调用 Handler#handleMessage(Message) 来分发处理该消息。

handler 引用 Activity 阻止了GC对Acivity的回收

在Java中，非静态(匿名)内部类会默认隐性引用外部类对象。而静态内部类不会引用外部类对象。
如果外部类是Activity，则会引起Activity泄露。

当Activity finish后，延时消息会继续存在主线程消息队列中1分钟，然后处理消息。而该消息引用了Activity的Handler对象，然后这个Handler又引用了这个Activity。这些引用对象会保持到该消息被处理完，这样就导致该Activity对象无法被回收，从而导致了上面说的 Activity泄露。

如何避免修？

使用显形的引用，1.静态内部类。 2. 外部类
使用弱引用 2. WeakReference