多线程

Android 多线程

---

个人理解，难免有些片面望大佬们扔砖

• 一：进程和线程的区别？

  进程线程区别

  1. 一个程序最少有一个进程 ，一个进程最少包含一个线程

• 二：AndroidApi提供的 线程方法：

  1. UI线程：（主线程）用于App与用户交互加载控件页面响应

  2. 子线程：用于处理 程序耗时的数据操作网络操作等…

• 三：Android提供耗时线程处理方法如下
  
  1. Thread + Hander
  2. AsyncTask
  3. IntentSerivce
  4. ThreadPoolExecutor

Thread

1. Thread类实现了Runnable接口 实现run()方法处理耗时操作

   public interface Runnable {/** * When an object implementing interface <code>Runnable</code> is used * to create a thread, starting the thread causes the object's * <code>run</code> method to be called in that separately executing * thread. * <p> * The general contract of the method <code>run</code> is that it may * take any action whatsoever. * * @see     java.lang.Thread#run() */    public abstract void run();}

Api说明：

Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。
设计该接口的目的是为希望在活动时执行代码的对象提供一个公共协议。例如，Thread 类实现了 Runnable。激活的意思是说某个线程已启动并且尚未停止。
此外，Runnable 为非 Thread 子类的类提供了一种激活方式。通过实例化某个 Thread 实例并将自身作为运行目标，就可以运行实现 Runnable 的类而无需创建 Thread 的子类。大多数情况下，如果只想重写 run() 方法，而不重写其他 Thread 方法，那么应使用 Runnable 接口。这很重要，因为除非程序员打算修改或增强类的基本行为，否则不应为该类创建子类。

• Thread 暂停销毁

  if (mThread != null && mThread.isAlive()) { //判断线程状态--是否在活动状态        mThread.interrupt(); //终止线程        mThread = null; //滞空    } 

• Thread 线程通知Ui线程：Hander

Hander

1. Android主线程包含一个消息队列(MessageQueue)，该消息队列里面可以存入一系列的Message或Runnable对象。通过一个Handler你可以往这个消息队列发送Message或者Runnable对象，并且处理这些对象。每次你新创建一个Handle对象，它会绑定于创建它的线程(也就是UI线程)以及该线程的消息队列，从这时起，这个handler就会开始把Message或Runnable对象传递到消息队列中，并在它们出队列的时候执行它们。

2. Handler可以把一个Message对象或者Runnable对象压入到消息队列中，进而在UI线程中获取Message或者执行Runnable对象，Handler把压入消息队列有两类方式，Post和sendMessage：
   private Handler mHandler = new MyHendler(this);
   private static class MyHendler extends Handler {
   private WeakReference mReference;

   public MyHendler(Context context) {    mReference = new WeakReference<Context>(context);}@Overridepublic void handleMessage(Message msg) {    ActivityTest activity = (ActivityTest) mReference.get(); //防治handler持有content对象 弱引用}}

AsyncTask:官方说明

AsyncTaskpublic abstract class AsyncTask extends Object java.lang.Object   ↳    android.os.AsyncTask<Params, Progress, Result>AsyncTask enables proper and easy use of the UI thread. This class allows you to perform background operations and publish results on the UI thread without having to manipulate threads and/or handlers.AsyncTask is designed to be a helper class around Thread and Handler and does not constitute a generic threading framework. AsyncTasks should ideally be used for short operations (a few seconds at the most.) If you need to keep threads running for long periods of time, it is highly recommended you use the various APIs provided by the java.util.concurrent package such as Executor, ThreadPoolExecutor and FutureTask.An asynchronous task is defined by a computation that runs on a background thread and whose result is published on the UI thread. An asynchronous task is defined by 3 generic types, called Params, Progress and Result, and 4 steps, called onPreExecute, doInBackground, onProgressUpdate and onPostExecute.

AsyncTask must be subclassed to be used. The subclass will override at least one method (doInBackground(Params…)), and most often will override a second one (onPostExecute(Result).)

Here is an example of subclassing:

//示例

 private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> { protected Long doInBackground(URL... urls) {     int count = urls.length;     long totalSize = 0;     for (int i = 0; i < count; i++) {         totalSize += Downloader.downloadFile(urls[i]);         publishProgress((int) ((i / (float) count) * 100));         // Escape early if cancel() is called         if (isCancelled()) break;     }     return totalSize; } protected void onProgressUpdate(Integer... progress) {     setProgressPercent(progress[0]); } protected void onPostExecute(Long result) {     showDialog("Downloaded " + result + " bytes"); } }

Once created, a task is executed very simply: ###

//初始化调用

new DownloadFilesTask().execute(url1, url2, url3);

AsyncTask’s generic types:

//参数说明

The three types used by an asynchronous task are the following:

1. Params, the type of the parameters sent to the task upon execution.
2. Progress, the type of the progress units published during the background computation.
3. Result, the type of the result of the background computation.

Not all types are always used by an asynchronous task. To mark a type as unused, simply use the type Void:

private class MyTask extends AsyncTask<Void, Void, Void> { ... }

The 4 steps:

//步骤

When an asynchronous task is executed, the task goes through 4 steps:

1. onPreExecute(), invoked on the UI thread before the task is executed. This step is normally used to setup the task, for instance by showing a progress bar in the user interface.
2. doInBackground(Params…), invoked on the background thread immediately after onPreExecute() finishes executing. This step is used to perform background computation that can take a long time. The parameters of the asynchronous task are passed to this step. The result of the computation must be returned by this step and will be passed back to the last step. This step can also use publishProgress(Progress…) to publish one or more units of progress. These values are published on the UI thread, in the onProgressUpdate(Progress…) step.
3. onProgressUpdate(Progress…), invoked on the UI thread after a call to publishProgress(Progress…). The timing of the execution is undefined. This method is used to display any form of progress in the user interface while the background computation is still executing. For instance, it can be used to animate a progress bar or show logs in a text field.
4. onPostExecute(Result), invoked on the UI thread after the background computation finishes. The result of the background computation is passed to this step as a parameter.

Cancelling a task

//取消线程

A task can be cancelled at any time by invoking cancel(boolean). Invoking this method will cause subsequent calls to isCancelled() to return true. After invoking this method, onCancelled(Object), instead of onPostExecute(Object) will be invoked after doInBackground(Object[]) returns. To ensure that a task is cancelled as quickly as possible, you should always check the return value of isCancelled() periodically from doInBackground(Object[]), if possible (inside a loop for instance.)

Treading rules

//线程规则

• The AsyncTask class must be loaded on the UI thread. This is done automatically as of JELLY_BEAN.
• The task instance must be created on the UI thread.
• execute(Params…) must be invoked on the UI thread.
• Do not call onPreExecute(), onPostExecute(Result), doInBackground(Params…), onProgressUpdate(Progress…) manually.
• The task can be executed only once (an exception will be thrown if a second execution is attempted.)