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<Integer,Integer,String> {
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<String,Integer,String> {
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<Runnable> 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);
}
