AsyncTask使用详解

一、基础篇
1）UI线程概念
         Android为单线程模型。当一个程序第一次启动时，Android会自动创建一个对应的主线程（Main Thread）。它负责把事件分派到相应的控件，用于用户与Android控件进行交互。所以通常又被叫做UI线程。
         在开发Android应用时必须遵守单线程模型的原则：Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行。
         简单表述为：1、不要阻塞UI线程；2、只能在主线程操作UI。

         详见Android帮助文档Dev Guide,左侧栏Processes and Threads。

2）UI线程示例
2.1）UI线程阻塞
         不考虑Android单线程模型，将所有任务都在该线程中执行，尤其是某些耗时操作，会使得整个用户界面被阻塞。从用户角度来看，就是按键或触屏后响应很慢甚至毫无响应。而且当应用程序阻塞的时间过长时，Android还会向用户提示一个无响应的对话框（不截了==）。

2.2）非主线程更新UI
         1、LogCat会报如下的错误消息：

         Uncaught handler: thread Thread-9 exiting due to uncaught exception。

         android.view.ViewRoot$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

         2、Android会向用户提示一个强行关闭的对话框（又不截了==）。

2.3）非主线程更新UI
         三种方式：①Handler；②View.post(Runnable)；③Activity.runOnUiThread(Runnable)。

2.4）好了，开始动手测试吧^^

• public class UIThreadActivity extends BaseActivity {
•     /** 标签 */
•     private TextView textView;
•     /** Runnable */
•     private Runnable runnable = new Runnable() {
•         @Override
•         public void run() {
•             logThreadId(); // 打印当前线程ID
•             textView.setText(tag + ", I'm Join!"); // 执行UI操作
•         }
•     };
•     @Override
•     protected void onCreate(Bundle savedInstanceState) {
•         super.onCreate(savedInstanceState);
•         setContentView(R.layout.ui_thread);
•         tag = "UIThreadActivity";
•         textView = (TextView) findViewById(R.id.textView);
•     }
•     /** 1.1 UI线程阻塞 */
•     public void blockUi(View v) {
•         tag = "blockUi";
•         logThreadId(); // 打印当前线程ID
•         /* 读取网页内容并显示 */
•         textView.setText("开始读取网页！"); // 该步可能未显示，为什么？
•         StringBuffer document = loadHtml("http://www.google.com"); // 耗时操作：读取网页源码
•         textView.setText(null == document ? "读取失败！" : document.toString()); // 显示网页源码
•         /**
•          * 1.观察按钮呈按下状态持续时间
  
•          * 2.尝试在按钮呈按下状态时，进行按键和触屏操作
  
•          */
•     }
•     /** 1.2 非主线程更新UI */
•     public void updateUi(View v) {
•         tag = "updateUi";
•         new Thread(runnable).start();
•     }
•     /** 2.1 方法1：Handler */
•     public void methodOne(View v) {
•         tag = "methodOne";
•         // Can't create handler inside thread that has not called
•         // Looper.prepare();
•         final Handler handler = new Handler();
•         new Thread(new Runnable() {
•             @Override
•             public void run() {
•                 logThreadId(); // 打印当前线程ID
•                 handler.post(runnable);
•                 // handler.postDelayed(runnable, 1000);
•             }
•         }).start();
•     }
•     /** 2.2 方法2: View.post(Runnable) */
•     public void methodTwo(View v) {
•         tag = "methodTwo";
•         new Thread(new Runnable() {
•             @Override
•             public void run() {
•                 logThreadId(); // 打印当前线程ID
•                 textView.post(runnable);
•                 // textView.postDelayed(runnable, 1000);
•             }
•         }).start();
•     }
•     /** 2.3 方法3：Activity.runOnUiThread(Runnable) */
•     public void methodThree(View v) {
•         tag = "methodThree";
•         new Thread(new Runnable() {
•             @Override
•             public void run() {
•                 logThreadId(); // 打印当前线程ID
•                 runOnUiThread(runnable);
•             }
•         }).start();
•     }
•     /**
•      * 读取网页源码
•      */
•     private StringBuffer loadHtml(String urlStr) {
•         try {
•             StringBuffer doc = new StringBuffer();
•             URL url = new URL(urlStr);
•             URLConnection conn = url.openConnection();
•             BufferedReader reader = new BufferedReader(new InputStreamReader(
•                     conn.getInputStream()));
•             String line = null;
•             while ((line = reader.readLine()) != null)
•                 doc.append(line);
•             reader.close();
•             return doc;
•         } catch (IOException e) {
•             e.printStackTrace();
•         }
•         return null;
•     }
• } 
  

         亲，记得看Log日志出的线程id哦。（卖下萌，不介意吧？）

二、提高篇
1）Android消息处理机制
         熟悉Android开发的可能知道其应用程序都是由消息驱动的。参考了Windows的消息循环机制，Android系统通过Handler、Thread、Looper以及MessageQueue实现了这种消息机制。相关的类都被定义在了package android.os。
         推荐这篇博客咯——解析Android消息处理机制。（这个，那个，还建模==）

2）实用的消息处理方式
2.1）Thread实现消息循环

• /** 1.1 Thread实现消息循环 */
• public void methodOne(View v) {
•     tag = "methodOne";
•     // 创建一个LooperThread对象，实现了消息循环
•     LooperThread thread = new LooperThread();
•     // 必须启动这个线程
•     thread.start();
•     // 创建一个消息对象并设置信息
•     Message msg = new Message();
•     Bundle bundle = new Bundle();
•     bundle.putString("key", "1.1 Thread实现消息循环");
•     msg.setData(bundle);
•     // 发送消息对象
•     thread.mHandler.sendMessage(msg);
• }
• /** 实现消息循环的线程（在Android索引文档android.os.Looper的概述里有介绍） */
• private class LooperThread extends Thread {
•     public Handler mHandler;
•     public void run() {
•         Looper.prepare();
•         mHandler = new Handler() {
•             public void handleMessage(Message msg) {
•                 // process incoming messages here
•                 logThreadId(); // 打印当前线程ID
•                 Log.e(tag, msg.getData().getString("key"));
•             }
•         };
•         Looper.loop();
•     }
• } 
  

         如果不使用Looper.prepare()及loop()的话，就不能创建Handler将消息处理加入到Looper中。LogCat会报“Can't create handler inside thread that has not called Looper.prepare();”的错误信息。

2.2）Handler与Looper相关联
         如果构造一个无参的Handler对象，它将自动与当前运行线程相关联。可以注意Handler相关例子中打印出的当前线程ID信息。
         而与Looper相关联，需要创建一个带参数的Handler对象。注意：此时线程类应该是一个HandlerThread类，一个Looper类的Thread类。

• /** 1.2 Handler与Looper相关联 */
• public void methodTwo(View v) {
•     tag = "methodTwo";
•      
•     // 生成一个HandlerThread对象，使用Looper来处理消息队列
•     HandlerThread thread = new HandlerThread("MyThread");
•     // 必须启动这个线程
•     thread.start();
•     // 将一个线程绑定到Handler对象上，则该Handler对象就可以处理线程的消息队列
•     MyHandler myhandler = new MyHandler(thread.getLooper());
•     // 从Handler中获取消息对象
•     Message msg = myhandler.obtainMessage();
•     // 设置消息对象信息
•     Bundle bundle = new Bundle();
•     bundle.putString("key", "1.2 Handler与Looper相关联");
•     msg.setData(bundle);
•     // 将消息对象发送给目标对象Handler
•     msg.sendToTarget();
• }
• /** 重写Handler的消息处理方法 */
• private class MyHandler extends Handler {
•     // 带有参数的构造函数
•     public MyHandler(Looper looper) {
•         super(looper);
•     }
•     @Override
•     public void handleMessage(Message msg) {
•         // process incoming messages here
•         logThreadId(); // 打印当前线程ID
•         Log.e(tag, msg.getData().getString("key"));
•     }
• } 
  

         所以，Wifi的HandlerThread，WifiHandler可以这样实例化（推荐博客有述）： 

• HandlerThread wifiThread = new HandlerThread("WifiService");
• wifiThread.start();
• mWifiHandler = new WifiHandler(wifiThread.getLooper()); 
  

2.3）Hanlder与Thread实现异步
         在新线程中执行耗时操作，结束后通过Handler来更新UI。

• /** 1.3 Hanlder与Thread实现异步 */
• public void methodThree(View v) {
•     tag = "methodThree";
•     /* 初始化进度条 */
•     progressBar.setProgress(0);
•     progressBar.setVisibility(View.VISIBLE);
•     // 新线程执行某操作
•     new ProgressThread(0).start();
• }
• /** 更新UI */
• private Handler myHandler = new Handler() {
•     @Override
•     public void handleMessage(Message msg) {
•         progressBar.setProgress(msg.getData().getInt("key"));
•     }
• };
• /** 新线程任务 */
• private class ProgressThread extends Thread {
•     private int progress;
•     public ProgressThread(int progress) {
•         this.progress = progress;
•     }
•     @Override
•     public void run() {
•         try {
•             while (progress <= 100) {
•                 progress += 5; // 进度+5
•                 // doSomething(); // 执行耗时操作
•                 Thread.sleep(100);
•                 // 从Handler中获取消息对象
•                 Message msg = myHandler.obtainMessage();
•                 // 设置消息对象信息
•                 Bundle b = new Bundle();
•                 // 向Handler发送消息，更新UI
•                 b.putInt("key", progress);
•                 msg.setData(b);
•                 myHandler.sendMessage(msg);
•             }
•         } catch (InterruptedException e) {
•             e.printStackTrace();
•         }
•     }
• } 
  

3）Android异步线程——AsyncTask
         当任务需要复杂操作并频繁更新UI时，上述的非主线程访问UI方法会使得代码结构复杂和难以理解。所以Android1.5提供了一个工具类AsyncTask，用以创建与用户界面交互的长时间任务。也在被定义在了package android.os。
         AsyncTask定义了3种泛型类型： Params, Progress and Result；4个执行步骤：onPreExecute, doInBackground, onProgressUpdate and onPostExecute。

3.1）泛型类型
         1) Params，发送给后台任务处理的参数类型
         2) Progress，后台任务过程中发布的进度单位
         3) Result，后台任务结束后返回的结果类型

         想了解泛型类型的话，可参见我的Java泛型应用浅析一文^^。 

3.2）执行步骤
         1) onPreExecute()，该方法将在执行实际的后台操作前被UI thread调用。可以在该方法中做一些准备工作，如在界面上显示一个进度条。
         2) doInBackground=\'#\'" publishProgress方法来更新实时的任务进度。该方法是抽象方法，子类必须实现。
         3) onProgressUpdate(Progress...)，在publishProgress方法被调用后，UI thread将调用这个方法从而在界面上展示任务的进展情况，例如通过一个进度条进行展示。
         4) onPostExecute(Result)，在doInBackground执行完成后，onPostExecute方法将被UI thread调用，后台的计算结果将通过该方法传递到UI thread。

         onPostExecute的参数为doInBackground的返回值，类型由第三个泛型类型所指定。例子里仅是String，也可以是你自己的实体类、接口什么的。

3.3）使用准则
         1) Task的实例必须在UI thread中创建
         2) execute方法必须在UI thread中调用
         3) 不要手动的调用onPreExecute(), onPostExecute(Result)，
doInBackground=\'#\'" onProgressUpdate(Progress...)这几个方法
         4) 该task只能被执行一次，否则多次调用时将会出现异常

3.4）任务取消
         一个任务在任何时候都能够通过调用cancel(boolean)而取消。调用这个方法，将使得随后调用的isCancelled()返回true。并且在执行完 doInBackground(Object[])后，会去调用onCancelled(Object)而不再是onPostExecute(Object)方法。
         为了确保任务能够尽快的被取消，可以在doInBackground(Object[])内定期校验isCancelled()的返回值（例如在循环判断中）。

3.5）样例程序

• /** 2 Android异步线程——AsyncTask */
• public void methodFour(View v) {
•     tag = "methodFour";
•     new LoadHtmlTask(this).execute("http://www.baidu.com"); // 执行读取网页任务
•     // new LoadHtmlTask(this).execute("http://www.google.com"); // 获取不到内容长度
•     // new LoadHtmlTask(this).execute("http://www.sina.com"); // 获取大量网页数据
• }
• /** 读取网页任务 */
• private class LoadHtmlTask extends AsyncTask {
•     private Context mContext;
•     private ProgressDialog dialog; // 进度框
•     public LoadHtmlTask(Context context) {
•         this.mContext = context;
•         initDialog(); // 初始化进度对话框
•     }
•     /** 初始化进度对话框 */
•     private void initDialog() {
•         dialog = new ProgressDialog(mContext);
•         dialog.setMax(100); // 设置最大进度值
•         dialog.setTitle("Loading..."); // 设置标题
•         dialog.setCancelable(false); // 设为返回键不可取消
•         dialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL); // 设为进度条样式
•         // 增加取消按钮及其事件
•         dialog.setButton("取消", new DialogInterface.OnClickListener() {
•             public void onClick(DialogInterface dialog, int i) {
•                 dialog.dismiss(); // 取消显示
•                 cancel(true); // 取消并中断任务
•             }
•         });
•     }
•     /** doInBackground之前，在主线程执行 */
•     @Override
•     protected void onPreExecute() {
•         logThreadId("onPreExecute()"); // 打印当前线程ID
•         dialog.show(); // 显示进度对话框
•     }
•     /** onPreExecute()之后，在后台线程执行 */
•     @Override
•     protected String doInBackground=\'#\'" /span>
•         logThreadId("doInBackground"); // 打印当前线程ID
•         // 未传入参数直接返回
•         if (null == params || params.length <= 0) {
•             return "请确认输入了网址参数！";
•         }
•         try {
•             // 创建HttpGet对象，params[0]为url
•             HttpGet httpGet = new HttpGet(params[0]);
•             // 发送Http Get请求，并返回HttpResponse对象
•             HttpResponse response = new DefaultHttpClient()
•                     .execute(httpGet);
•             // 判断响应状态，200表示成功响应
•             if (response.getStatusLine().getStatusCode() == 200) {
•                 HttpEntity entity = response.getEntity(); // 获取返回结果
•                 long length = entity.getContentLength(); // 获取内容长度（google获取不到）
•                 boolean getLen = length > 0 ? true : false; // 判断是否获取了内容长度
•                 InputStream is = entity.getContent(); // 获取响应内容
•                 if (is != null) {
•                     ByteArrayOutputStream baos = new ByteArrayOutputStream();
•                     byte[] buf = new byte[128];
•                     int ch = -1;
•                     long count = 0;
•                     while ((ch = is.read(buf)) != -1 && !isCancelled()) { // 同时还未取消
•                         baos.write(buf, 0, ch);
•                         count += ch;
•                         if (getLen) { // 获取了内容长度时
•                             // 调用publishProgress()更新进度
•                             publishProgress((int) ((count / (float) length) * 100));
•                         }
•                     }
•                     is.close();
•                     baos.close();
•                     return new String(baos.toByteArray()); // 返回结果
•                 }
•                 return "无返回内容！";
•             } else {
•                 return "服务器未响应或失败！";
•             }
•         } catch (Exception e) {
•             e.printStackTrace();
•         }
•         return "程序异常啦！";
•     }
•     /** 调用了publishProgress()，在主线程执行 */
•     @Override
•     protected void onProgressUpdate(Integer... values) {
•         // logThreadId("onProgressUpdate"); // 打印当前线程ID
•         dialog.setProgress(values[0]);
•     }
•     /** 未调用了cancel()，doInBackground()结束后，在主线程执行 */
•     @Override
•     protected void onPostExecute(String result) {
•         logThreadId("onPostExecute(result)"); // 打印当前线程ID
•         dialog.dismiss(); // 取消显示
•         showMsg(result); // 显示结果
•     }
•     /** 调用了cancel()，doInBackground()结束后，在主线程执行 */
•     @Override
•     protected void onCancelled() {
•         logThreadId("onCancelled"); // 打印当前线程ID
•         showMsg("用户取消了该任务！");
•     }
•     /** 提示框显示消息 */
•     private void showMsg(String message) {
•         // message内容过多时，提示框显示会延迟，例如sina
•         new AlertDialog.Builder(mContext)
•                 .setTitle("消息")
•                 .setMessage(message)
•                 .setNegativeButton("关闭",
•                         new DialogInterface.OnClickListener() {
•                             @Override
•                             public void onClick(DialogInterface dialog,
•                                     int which) {
•                                 dialog.dismiss();
•                             }
•                         }).show();
•     }
• } 
  

三、扩展篇
1）Service中的Toast
         Service中不能直接使用Toast提示信息，推荐如下方式：

• private Handler handler; // Handler
• Override
• public void onCreate() {
•     Log.i("onCreate", "==onCreate==");
•     super.onCreate();
•     handler = new Handler(Looper.getMainLooper()); // 使用应用的主消息循环
• }
• /**
• * Toast提示（service中toast不能直接显示）
• */
• private void showToast(final int resId, final Object... formatArgs) {
•     handler.post(new Runnable() {
•         public void run() {
•             Toast.makeText(getApplicationContext(),
•                     getString(resId, formatArgs), Toast.LENGTH_SHORT)
•                     .show();
•         }
•     });
•     // 以下方式只能显示一次
•     // Looper.prepare();
•     // Toast.makeText(this, resId, Toast.LENGTH_SHORT).show();
•     // Looper.loop();
• } 
  

2）Java线程池
         一些简单常用的线程池，只需使用Executors类里面提供了一些静态工厂，如下：
         1）newSingleThreadExecutor：创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
         2）newFixedThreadPool：创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。
         3）newCachedThreadPool：创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
         4）newScheduledThreadPool：创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
         5）newSingleThreadExecutor：创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。
         或者使用ThreadPoolExecutor，更加定制化地构造线程池。它们都被定义在package java.util.concurrent。

         线程池技术是为了减少频繁创建和销毁线程的系统开销，适用情况有：1）单个任务时间很短、处理请求巨大；2）有突发性大量任务请求；3）需要迅速响应的性能要求等。

• public class TestPool implements Runnable {
•     private static final String TAG = "TestPool"; // 标记
•     private ExecutorService service; // 线程池
•     public TestPool() {
•         // service = Executors.newSingleThreadExecutor(); // 创建一个单任务线程池
•         service = Executors.newFixedThreadPool(3); // 创建最多同时运行3个任务线程池
•     }
•     /** 增加一个线程任务 */
•     public void addTask() {
•         service.execute(this);
•     }
•     /** 线程任务 */
•     @Override
•     public void run() {
•         log(1); // 显示日志
•         try {
•             Thread.sleep(5 * 1000);
•         } catch (InterruptedException e) {
•             e.printStackTrace();
•         }
•         log(2); // 显示日志
•     }
•     /** 显示日志 */
•     private void log(int which) {
•         String result = 1 == which ? "，任务开始！" : "，任务结束！";
•         Log.e(TAG, "线程：" + String.valueOf(Thread.currentThread().getId())
•                 + result);
•     }
• } 
  

3）Java线程同步
         多线程并发访问同一数据时，就会有同步的需求。Java内在的同步机制包含：同步块（或方法）和 volatile 变量。同步块（或方法）通过synchronized关键字声明，而volatile可被看做是轻量级的synchronized。

         Java为每个object分配了一个monitor，相关方法如下：
         1）obj.wait()方法将使本线程挂起，并释放obj对象的monitor。只有其他线程调用obj对象的notify()或notifyAll()时，才可以被唤醒。
         2）obj.notifyAll()方法唤醒所有该obj对象相关的沉睡线程，然后被唤醒的众多线程开始竞争obj对象的monitor占有权，最终得到的那个线程会继续执行下去，但其他线程还将继续等待。
         3）obj.notify()方法是随机唤醒一个沉睡线程。
         4）wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用。

         没多线程不需要同步，有多线程不一定需要同步。

• public class TestSync {
•     private Product product;
•     private Consumer ConsumerA, ConsumerB;
•     public TestSync() {
•         product = new Product();
•         ConsumerA = new Consumer("小怪兽A", product);
•         ConsumerB = new Consumer("小怪兽B", product);
•     }
•     public void produce() {
•         synchronized (product) {
•             Log.e("TestSync", "\\(^o^)/，投掷一个果冻！");
•             product.plus(); // 增加一个产品
•             /* 优先使用notifyAll()，更容易让jvm找到最适合被唤醒的线程 */
•             // product.notify(); // 唤醒一个线程
•             product.notifyAll(); // 唤醒所有线程
•         }
•     }
•     public void start() {
•         ConsumerA.start();
•         ConsumerB.start();
•     }
•     public void stop() {
•         ConsumerA.stopEating();
•         ConsumerB.stopEating();
•         synchronized (product) {
•             product.notifyAll(); // 唤醒所有线程
•         }
•     }
• }
• /** 产品 */
• class Product {
•     private int count = 0; // 产品数量
•     public Product() {
•     }
•     /** 是否无产品 */
•     public boolean isNull() {
•         return count <= 0 ? true : false;
•     }
•     /** 增加产品 */
•     public void plus() {
•         count++;
•     }
•     /** 减少产品 */
•     public void minus() {
•         count--;
•     }
• }
• /** 消费者 */
• class Consumer extends Thread {
•     private String name; // 消费者
•     private Product product; // 产品
•     private int count = 0; // 数量
•     private boolean waitEating = true; // 标记
•     public Consumer(String name, Product product) {
•         this.name = name;
•         this.product = product;
•     }
•     @Override
•     public void run() {
•         while (waitEating) {
•             synchronized (product) {
•                 while (product.isNull() && waitEating) {
•                     try {
•                         Log.e(name, "（¯﹃¯），等待果冻中...");
•                         product.wait();
•                     } catch (InterruptedException e) {
•                         e.printStackTrace();
•                     }
•                 }
•                 if (waitEating) {
•                     Log.e(name, "~\\(≧▽≦)/~，抢到了果冻！");
•                     product.minus();
•                     count++;
•                 }
•             }
•         }
•         Log.e(name, "(～ o ～)~zZ，吃不下了。计：" + count);
•     }
•     public void stopEating() {
•         waitEating = false;
•     }
• }