Android多线程编程

（来自《第一行代码》）整理总结

JAVA中的多线程

1、 继承Thread

class MyThread extends Thread {
@override
public void run() {
// 具体的处理逻辑
}
}

new MyThread().start();

2、实现Runnable

class MyThread implements Runnable {
@override
public void run() {
// 具体的处理逻辑
}
}

MyThread myThread = new MyThread();
new Thread(myThread).start();

3、匿名类的方式（最常用）

new Thread(new Runnable() {
@Override
public void run() {
// 处理具体的逻辑
}
}).start();

一、使用Handler（处理者）在子线程中更新UI:

<RelativeLayout 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" >

<Button
android:id="@+id/change_text"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:text="Change Text" />

<TextView
android:id="@+id/text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerInParent="true"
android:text="Hello world"
android:textSize="20sp" />

</RelativeLayout>

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends Activity implements OnClickListener {

public static final int UPDATE_TEXT = 1;// 表示更新TextView这个动作
private TextView text;
private Button changeText;

private Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case UPDATE_TEXT:
text.setText("Nice to meet you");
break;
default:
break;
}
}
};

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
text = (TextView) findViewById(R.id.text);
changeText = (Button) findViewById(R.id.change_text);
changeText.setOnClickListener(this);
}

@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.change_text:
new Thread(new Runnable() {
@Override
public void run() {
Message message = new Message();
message.what = UPDATE_TEXT;
handler.sendMessage(message);
}
}).start();
break;
default:
break;
}
}
}

机制：

1、Message是线程之间传递的消息，可以使用what字段，还可以使用arg1和arg2字段来携带一些整形数据，使用obj字段携带一个Object对象。

2、Handler主要用于发送和处理消息。发送消息一般是使用Handler的sendMessage()方法，而发出的消息经过一系列的辗转处理后，最终会传递到Handler的handleMessage()。

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

4、Looper是每个线程中的MessageQueue的管家。每个线程中也只会有一个Looper对象。负责将消息队列中的消息传递到Handler的handleMessage()的方法中。

过程：1、主线程创建Handler对象，重写handleMessage()方法；

2、在子线程中创建Message对象，然后发送；

3、消息被添加到消息队列中，Looper取出消息，分发到handleMessage()方法中安心地进行UI操作。

二、使用AsyncTask

/**
* AsyncTask基本用法
*
* @author Administrator
*
*/
class DownloadTask extends AsyncTask<Void, Integer, Boolean> {
// 三个参数分别表示(Params)在执行AsyncTask时需要传入的参数；
// (Progress)当前的进度；
// (Result)任务处理执行完毕后返回的结果
private ProgressDialog progressDialog;
private String[] valus;
private Context context;

private int doDownload() {
// TODO Auto-generated method stub
return 0;
}

// 界面上的初始化操作，比如显示一个进度条对话框
@Override
protected void onPreExecute() {
// 显示进度对话框
progressDialog.show();
}

// 在子线程中运行，处理耗时的任务
@Override
protected Boolean doInBackground(Void... params) {
try {
while (true) {
// 这是一个虚构的方法
int downloadPercent = doDownload();
// 调用publishProgress(Progress...)反馈当前任务的执行进度
publishProgress(downloadPercent);
if (downloadPercent >= 100) {
break;
}
}
} catch (Exception e) {
return false;
}
return true;
}

// 在任务中调用publishProgress(Progress...)后，这个方法很快被调用，在这里可进行UI操作
@Override
protected void onProgressUpdate(Integer... values) {
// 在这里更新下载进度
progressDialog.setMessage("Downloaded " + valus[0] + "%");
}

// 后台任务执行完毕并通过return语句进行返回，这个方法被调用，可利用返回的数据进行UI操作（收尾工作）
@Override
protected void onPostExecute(Boolean result) {
// 关闭进度对话框
progressDialog.dismiss();
// 提醒任务执行的结果
if (result) {
Toast.makeText(context, "Download succeeded", Toast.LENGTH_SHORT).show();
} else {
Toast.makeText(context, "Download failed", Toast.LENGTH_SHORT).show();
}
}

两者比较：

AsyncTask在代码上比Handler要轻量级，而实际上要比Handler更耗资源，因为AsyncTask底层是一个线程池，而Handler仅仅是发送了一个消息队列。

但是，如果异步任务的数据特别庞大，AsyncTask线程池的结构优势就体现出来。