Android的线程和线程池

Android的线程和线程池

标签（空格分隔）： android

---

一些概念：

• 线程分类：主线程和子线程，主线程主要处理和界面相关的事情，子线程用于执行耗时操作。
• 如果在主线程即ui线程执行耗时操作，会造成ANR，即无法响应。
• 一些特殊的线程：AsyncTask（主要用于更新ui）、IntentService（更方便执行后台任务，不容易被杀死）、HanderThread，AsyncTask底层实现是线程池，IntentService、HanderThread底层是线程。
• 线程池都可以避免因为频发创建和摧毁线程带来的系统开销。

一些特殊的线程：

AsyncTask

• 定义：AsyncTask是一种轻量级的异步任务类，它在线程池中执行后台任务，执行的进度和最终结果传递给主线程并在主线程中更新ui。
• AsyncTask的一些方法和参数：
  • 参数：Params表示参数类型，Progress表示后台任务执行进度的类型，而Result表示后台任务的返回结果类型。
  • 核心方法：
    （1）onPreExecute（）：在主线程执行，可以用于做一些·准备工作。
    （2）doInBackgroud（）：在线程池执行，此方法执行异步任务，params是异步任务的参数，其中的publishProgress方法会调用onProgressUpdate方法，此方法返回结果给onPostExecute方法。
    （3）onProgressUpdate 在主线程中执行，后台任务的执行进度发生变化此方法会被调用。
    （4）onPostExecute 在主线程中执行，异步任务执行之后，此方法会被调用。
• 一个简单的例子：

/*
自定义的一个AsyncTask类
*/
package com.example.windowtest;

import android.os.AsyncTask;
import android.widget.ProgressBar;
import android.widget.TextView;

public class MyAsyncTask extends AsyncTask {
    private TextView txt;
    private ProgressBar pgbar;
    public MyAsyncTask(TextView txt,ProgressBar pgbar){
        super();
        this.txt = txt;
        this.pgbar = pgbar;
    }

    @Override
    protected String doInBackground(Integer... integers) {
        DelayOperator dop = new DelayOperator();
        int i;
        for(i=10;i<=100;i+=10){
            dop.delay();
            publishProgress(i);
        }
        return i+integers[0].intValue()+"";
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        txt.setText("开始执行异步线程~");
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        super.onProgressUpdate(values);
        int value = values[0];
        pgbar.setProgress(value);
    }
}
/*
模拟耗时操作的类
*/
package com.example.windowtest;

public class DelayOperator {
    public void delay(){
        try{
           Thread.sleep(1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}


//主线程中调用代码
  btnupdate.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                MyAsyncTask myAsyncTask = new MyAsyncTask(txt_title,pgbar);
                myAsyncTask.execute(1000);
            }
        });
  
  

运行结果：

更新进度条

• AsncTask工作流程
  先上一张我手绘的图：（这字丑的不说了）

  
  
  

  AsyncTask

（1）先从execute方法开始，这个方法实际上就是调用了executeOnExecutor方法。
（2）这个executeOnExecutor的方法就做了很多的事情，实现一个线程池，同时onPreExecute方法也被执行了。
（3）关于sDefaultExecutor线程池，把AsyncTask的params封装为FutureTask对象，FutureTask对象又交给线程池的execute方法处理。通过判断线程池中是否有线程执行，如果没有，执行scheduleNext启动下一个任务。
（4）实际上AsyncTask有两个线程池，一个是用来排队的SerialExecutor用来排队，线程池THREAD_POOL_EXECUTOR执行真正的任务，而InternalHandler是用来实现将执行环境切换回主线程。
（5）接下来是切换回主线程的逻辑，调用mWorker的call方法，执行postResult，该方法的参数是doInBackground方法的返回结果，postResult方法会调用sHandler发送消息，切回主线程。
（6）handleMessage会接受两种msg.what,一种是(1)POST_RESULT、(2)POST_PROGRESS,(1)消息标识会执行Taskfinish方法（任务被取消执行onCancelled方法，任务没有被取消就执行onPostExecute方法），（2）消息标识会执行onProgressUpdate方法。

想到一个问题，AsyncTask任务是串行还是并行的？

答：android3.0以下版本是并行的，android3.0以上的版本是串行的，
调用AsyncTask的executeOnExecutor方法任务会并行。

代码验证：

package com.example.asynctaskdemo;

import android.content.Intent;
import android.os.AsyncTask;
import android.os.Build;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import java.text.SimpleDateFormat;
import java.util.Date;

public class MainActivity extends AppCompatActivity {
    private Button start_async,intent_service;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        start_async = (Button)findViewById(R.id.start_async_task);
        intent_service = (Button)findViewById(R.id.intent_service);
    }

    public void onClick(View v){
        if(v.getId() == R.id.start_async_task){
            //串行
            new MyAsyncTask("AsyncTask#1").execute("");
            new MyAsyncTask("AsyncTask#2").execute("");
            new MyAsyncTask("AsyncTask#3").execute("");
            new MyAsyncTask("AsyncTask#4").execute("");
            }
            //并行
             if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB){
                new MyAsyncTask("AsyncTask#5").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR," ");
                new MyAsyncTask("AsyncTask#6").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR," ");
                new MyAsyncTask("AsyncTask#7").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR," ");
                new MyAsyncTask("AsyncTask#8").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR," ");
            }
        }else if(v.getId() == R.id.intent_service){
            Intent service = new Intent(this,LocalIntentService.class);
            service.putExtra("task_action","com.example.action.TASK1");
            startService(service);
            service.putExtra("task_action","com.example.action.TASK2");
            startService(service);
            service.putExtra("task_action","com.example.action.TASK3");
            startService(service);
        }
    }
    private static class MyAsyncTask extends AsyncTask {
        private String mName = "AsyncTask";
        private MyAsyncTask(String name){
            super();
            mName = name;
        }

        @Override
        protected String doInBackground(String... strings) {
            try{
                Thread.sleep(3000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            return mName;
        }

        @Override
        protected void onPostExecute(String s) {
            super.onPostExecute(s);
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Log.e("haha",s+"execute finish at " +df.format(new Date()));
        }
    }
}

AsyncTask串行

AsyncTask并行

简单介绍特殊的服务IntentService

• 简单介绍：IntentService的优先级比一般的线程的优先级高，它特别适合执行高优先级的后台任务。
• 第一次启动：onCreate方法会被调用，onCreate方法会创建HandlerThread，然后他的Looper来构建一个Handler对象mServiceHandler，mServiceHandler发送消息，执行HandlerThread的后台任务。
• 每一次启动IntentService，onStartCommand方法就会调用一次，IntentService在onStartCommand中处理每一个后台任务的Intent。
• 之后的调用过程：onStart方法--》（发送一条消息）mServiceHandler--》（传递给onHandleIntent）onHandleIntent --》（调用结束后）stopSelf（）尝试停止服务
• stopSelf（）是立即停止服务，stopSelf（int startId）是等待所有任务处理完后停止服务。
• 每执行一个后台任务就必须启动一次IntentService，而IntentService内部则通过消息的方式向HandlerThread请求执行任务。所以IntentService的后台任务按顺序执行。

android中的线程池

三大优点

（1）重用线程池中的线程，避免线程创建和线程销毁带来的性能开销
（2）能有效地控制最大的并发数，避免大量线程相互抢占资源而导致阻塞现象
（3）能够简单地实现线程地管理

配置线程池

public ThreadPoolExecutor(int corePoolSize,//核心线程数
                          int maxinumPoolSize,//最大线程数
                          long keepAliveTime,//超时时长
                          TimeUnit unit,//时间单位
                          BlockingQueue workQueue,//线程池的任务队列
                          ThreadFactory threadFactory//线程工厂)

关于线程池执行任务的规律：（自己写的口诀）

• 核心未满，开核心；核心已满，插入线程池的队列；队列已满，开普通线程；线程已满，通知调用者，抛出异常。

几种常见的线程池

1、FixedThreadPool

• 全是核心线程，不会被回收
• 没有超时机制，更快地响应外界请求

2、CachedThreadPool

• 适合于大量耗时较少的任务
• 只有非核心线程，有超时机制，会被回收。
• 无法存储元素的队列（空集合)
• 线程数是一个不定的值，非常大，可以认为是一个任意的数。

3、ScheduledThreadPool

• 执行定时任务和具有固定周期的重复任务
• 核心线程是固定的，非核心线程是没有限制的，非核心线程闲置时会被回收

4、SingleThreadExecutor

• 只有一个核心线程，确保所有任务在一个线程中顺序执行。
• 不需要处理线程同步的问题

private void init(){
        Runnable command = new Runnable() {
            @Override
            public void run() {
                SystemClock.sleep(3000);
            }
        };
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);
        fixedThreadPool.execute(command);
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        cachedThreadPool.execute(command);
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);
        scheduledThreadPool.schedule(command,2000, TimeUnit.MILLISECONDS);
        scheduledThreadPool.scheduleAtFixedRate(command,10,1000,TimeUnit.MILLISECONDS);
        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
        singleThreadPool.execute(command);
    }