Android开发之多线程

Android消息处理机制

  由于操作UI只能在主线程进行，所以当需要在子线程中更新UI时就需要用到Handler，而Message便是Handler需要接收的消息对象。每发送一次Message对象，该对象便会添加进Message队列MessageQueue中，该队列遵循先进先出的原则，MessageQueue在初始化Looper时创建。Looper则来管理该队列，每一个线程只能有一个Looper。

它们对应关系如下图：

以下为demo：

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.widget.TextView;

/**
 * Created by ASUS on 2018/1/11.
 */

public class Handlers {

    private TextView title;
    private static final String TAG=Handlers.class.getSimpleName();

    public Handlers(TextView title){
        this.title=title;
        MyThread myThread=new MyThread();
        Thread thread=new Thread(myThread);
        thread.start();
    }

    /**
     * 此处出现内存溢出现象
     */
    private  Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if(title!=null){
                title.setText("接到消息");
            }
            System.out.println("what:"+msg.what);
            String str=new String(msg.getData().getCharArray("bundle"));
            System.out.println("arg1:"+msg.arg1);
            System.out.println("arg2:"+msg.arg2);
            System.out.println("bundle:"+str);
        }
    };

    class MyThread implements Runnable{
            public MyThread(){
            }
        @Override
        public void run() {
            System.out.println("线程已启动");
            Bundle bundle=new Bundle();
            char[] chars={'m','s','g'};
            bundle.putCharArray("bundle",chars);
            //obtain(Handler h, int what, int arg1, int arg2)
            Message message=Message.obtain(handler,1,1,2);
            message.setData(bundle);
            message.sendToTarget();
            //第二种写法
//            Message message=Message.obtain();
//            message.what=1;
//            message.arg1=1;
//            message.arg2=2;
//            message.obj=bundle;
//            handler.sendMessage(message);
            //第三种写法
            //sendEmptyMessage(int what)
//          handler.sendEmptyMessage(1);
        }
    }
}

  第一种写法先绑定Handler再调用Message对象的sendToTarget方法发送，第二种直接通过Handler对象的sendMessage方法发送，第三种方法是发送一个仅有what参数的空Message对象。
  当Handler接收到Message对象时，便会调用handlerMessage方法，可以在该方法中处理UI。

API参考：
Handler
Message

AsyncTask的使用

  该抽象类需要重写四个方法，分别为：
    onPreExecute，doInBackground，onProgressUpdate，onPostExecute。
  其作用分别为：后台任务开始时调用，用于界面的初始化操作；执行费时的后台任务；在doInBackground中执行onProgressUpdate方法后调用，在该方法更新UI；后台任务执行完毕doInBackground中return后执行，可用来展示最终结果，如下载内容。

以下为demo：

注意以下代码为下载网页内容的demo，可以选择性看重点

import android.os.AsyncTask;
import android.util.Log;
import android.widget.Button;
import android.widget.ProgressBar;
import android.widget.TextView;


import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

/**
 * Created by ASUS on 2018/1/11.
 */

public class AsyncTasks extends AsyncTask<URL,Integer,String>{
    private  TextView proText;
    private Button start,stop;
    private ProgressBar proBar;
    private static final String TAG=AsyncTasks.class.getSimpleName();

    public AsyncTasks(TextView proText, Button start, Button stop, ProgressBar proBar){
        this.proText=proText;
        this.start=start;
        this.stop=stop;
        this.proBar=proBar;
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        start.setEnabled(false);
        stop.setEnabled(true);
    }

    @Override
    protected String doInBackground(URL... urls) {
        int pecentage,length,count=0;
        long total;
        try {
            HttpURLConnection httpURLConnection=(HttpURLConnection) urls[0].openConnection();
            httpURLConnection.setRequestMethod("GET");
            //Sets the value of the specified request header field.
            httpURLConnection.setRequestProperty("Accept-Encoding", "identity");
            httpURLConnection.setConnectTimeout(5000);
            Log.i(TAG,"url:"+urls[0].toString());
            httpURLConnection.connect();
            InputStream inp=httpURLConnection.getInputStream();
            ByteArrayOutputStream byteArrayOutputStream=new ByteArrayOutputStream();
            byte[] bytes=new byte[1024];
            total=httpURLConnection.getContentLength();
            Log.i(TAG,"total:"+String.valueOf(total));
            while((length=inp.read(bytes))!=-1){
                count+=length;
                Log.i(TAG,"length:"+length);
                pecentage=(int)(count/(float)total*100);
                Log.i(TAG,"pecentage:"+String.valueOf(pecentage));
                byteArrayOutputStream.write(bytes,0,bytes.length);
                publishProgress(pecentage);
            }
            return new String(byteArrayOutputStream.toByteArray(),"utf-8");
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        super.onProgressUpdate(values);
        proBar.setProgress(values[0]);
        proText.setText("loading..."+values[0]);
    }

    @Override
    protected void onPostExecute(String result) {
        super.onPostExecute(result);
        proText.setText(result);
        start.setEnabled(true);
        stop.setEnabled(false);
    }

    @Override
    protected void onCancelled() {
        super.onCancelled();
        proText.setText("loading...0%");
        start.setEnabled(true);
        stop.setEnabled(false);
    }
}

注意以下代码为MainActivity中的一部分，用于控制AsyncTask的启动

        start.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                URL url=null;
                asyncTasks=new AsyncTasks(proText,start,stop,proBar);
                try {
                    url=new URL("http://www.cnblogs.com/aosting/p/3436412.html");
                }catch (MalformedURLException e) {
                    e.printStackTrace();
                }
                asyncTasks.execute(url);
            }
        });
        stop.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                asyncTasks.cancel(true);
            }
        });

  可以看到AsyncTasks在继承AsyncTask类时传入了三个泛型参数，第一个为URL对应doInBackground的参数，第二个为Interget对应onProgressUpdate的参数（用于展示进度），第三个对应onPostExecute的参数（用于展示结果）。在AsyncTasks还重写了onCancelled方法，这个方法在asyncTasks.cancel(true)执行后会被调用。

API参考：
AsyncTask

在子线程中操作UI的方法：

1.通过上面提到的消息机制，以发送消息给主线程然后通知主线程操作UI

2.通过封装好的子线程操作UI的方法：

        runOnUiThread(new Runnable() {
            @Override
            public void run() {

            }
        });