Android开发十一《Android的线程和线程池》

2022-03-26 本文已影响0人独自闯天涯的码农

一、主线程和子线程

1、概述

含义：线程是CPU调度的最小单元。

特点：线程是一种受限的系统资源。即线程不可无限制的产生且线程的创建和销毁都有一定的开销。

二、Android中的线程形态

除了传统的Thread以外，还包含AsyncTask，HandlerThread以及IntentService，这三者底层实现也是线程。

1、AsyncTask

1. AsyncTask是一种轻量级的异步任务类，它可以在线程池中执行后台任务。

在Android中实现异步任务机制有两种方式：Handler和AsyncTask。

Handler机制存在的问题：代码相对臃肿；多任务同时执行时不易精确控制线程。
引入AsyncTask的优点：创建异步任务更简单，直接继承它可方便实现后台异步任务的执行和进度的回调更新UI，而无需编写任务线程和Handler实例就能完成相同的任务。

2. AsyncTask是抽象的泛型类，其组成成员有：

三个泛型参数：
Params：表示执行AsyncTask需要传入的参数，可用于在后台任务中使用；
Progress：表示后台任务执行的进度；
Result：表示后台任务的返回结果的类型；
若没有传递具体的参数，这三个泛型参数都可使用void。

public abstract class AsyncTask<Params, Progress, Result> {}

3. 五个核心方法:

onPreExecute()：
运行在：主线程
调用时刻：在异步任务执行之前被调用
作用：可用于进行一些界面上的初始化操作
doInBackground(Params…params)：
运行在：子线程
作用：可用于处理所有的耗时任务。若需要更新UI需调用 publishProgress(Progress...)方法
注意：任务一旦完成就通过return语句将任务的执行结果返回，若Result被指定为void，就可不返回执行结果
onProgressUpdate(Progress…values)：
运行在：主线程
调用时刻：在后台任务中调用publishProgress(Progress...)之后该方法会被调用
作用：可利用方法中携带的参数如Progress来对UI进行相应地更新
onPostExecute(Result result)：
运行在：主线程
调用时刻：在异步任务执行完毕并通过return语句返回时被调用
作用：可利用方法中返回的数据来进行一些UI操作
onCancelled()：
运行在：主线程
调用时刻：当异步任务被取消时被调用
作用：可用于做界面取消的更新

注意：
不要直接调用onPreExecute()、doInBackground()、onProgressUpdate()、onPostExecute)和onCancelled()方法
AsyncTask对象必须在主线程创建
执行顺序：onPreExecute() -> doInBackground() -> publishProgress() -> onProgressUpdate() -> onPostExecute()

4. 开始和结束异步任务的方法：

execute(Params...params)
必须在主线程中调用
作用：表示开始一个异步任务
注意：一个异步对象只能调用一次execute()方法
cancel(booleanmayInterruptIfRunning)
必须在主线程中调用
作用：表示停止一个异步任务

5. 使用

自定义一个AsyncTask

class DownloadTask extends AsyncTask<Void, Integer, Boolean> {  
  
    @Override//初始化一个ProgressDialog  
    protected void onPreExecute() {  
        progressDialog.show();  
    }  
  
    @Override//具体的下载逻辑
    protected Boolean doInBackground(Void... params) {  
        try {  
            while (true) {  
                int downloadPercent = doDownload();  
                publishProgress(downloadPercent);  
                if (downloadPercent >= 100) {  
                    break;  
                }  
            }  
        } catch (Exception e) {  
            return false;  
        }  
        return true;  
    }  
  
    @Override//显示当前的下载进度
    protected void onProgressUpdate(Integer... values) {  
        progressDialog.setMessage("当前下载进度：" + values[0] + "%");  
    }  
  
    @Override//提示任务的执行结果  
    protected void onPostExecute(Boolean result) {  
        progressDialog.dismiss();  
        if (result) {  
            Toast.makeText(context, "下载成功", Toast.LENGTH_SHORT).show();  
        } else {  
            Toast.makeText(context, "下载失败", Toast.LENGTH_SHORT).show();  
        }  
    }  
}

开启任务

// 开始任务  
DownloadTask mDownloadTask  = new DownloadTask();  
mDownloadTask .execute();  
   
// 停止任务  
mDownloadTask .cancel(true);

6. 原理

AsyncTask封装了Thread和Handler。

1. 内部有一个静态的Handler对象即InternalHandler：

作用：将执行环境从线程池切换到主线程；通过它来发送任务执行的进度以及执行结束等消息。

注意：必须在主线程中创建

2. 内部有两个线程池：

SERIAL_EXECUTOR：用于任务的排队，默认是串行的线程池
THREAD_POOL_EXECUTOR：用于真正执行任务。

3. 排队执行过程：

把参数Params封装为FutureTask对象，相当于Runnable；
调用SerialExecutor.execute()将FutureTask插入到任务队列tasks；
若没有正在活动的AsyncTask任务，则就会调用SerialExecutor.scheduleNext执行下一个AsyncTask任务。
scheduleNext方法中调用了THREAD_POOL_EXECUTOR.execute执行任务。
执行完毕后会继续执行其他任务直到所有任务都完成。即默认使用串行方式执行任务。

注意：AsyncTask不适用于进行特别耗时的后台任务，而是建议用线程池。

Android1.6之前：AsyncTask串行处理任务
Android1.6～Android3.0：AsyncTask并行处理任务
Android3.0之后：AsyncTask串行处理任务，仍可以调用executeOnExecutor方法来并行执行任务。

2、HandlerThread

1. HandlerThread是一个线程类，它继承自Thread;

与普通Thread的区别：具有消息循环的效果。原理：包含Looper

@Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

2. HandlerThread的使用

实例化一个HandlerThread对象，参数是该线程的名称；
通过 HandlerThread.start()开启线程；
实例化一个Handler并传入HandlerThread中的looper对象，使得与HandlerThread绑定；
利用Handler即可执行异步任务；
当不需要HandlerThread时，通过HandlerThread.quit()/quitSafely()方法来终止线程的执行。

private HandlerThread myHandlerThread ;  
private Handler handler ;  
@Override  
protected void onCreate(Bundle savedInstanceState) {  
    super.onCreate(savedInstanceState);  
   setContentView(R.layout.activity_main);  
   //实例化HandlerThread
   myHandlerThread = new HandlerThread("myHandler") ;  
   //开启HandlerThread
   myHandlerThread.start();  
   //将Handler对象与HandlerThread线程绑定
   handler =new Handler(myHandlerThread.getLooper()){  
       @Override  
        publicvoid handleMessage(Message msg) {  
           super.handleMessage(msg);  
            // 这里接收Handler发来的消息，运行在handler_thread线程中  
            //TODO...  
        }  
    };  
   
   //在主线程给Handler发送消息  
   handler.sendEmptyMessage(1) ;  
   new Thread(new Runnable() {  
       @Override  
        publicvoid run() {  
           //在子线程给Handler发送数据  
           handler.sendEmptyMessage(2) ;  
        }  
    }).start();  
}  
@Override  
protected void onDestroy() {  
   super.onDestroy();  
   //终止HandlerThread运行
   myHandlerThread.quit() ;  
}

3. 用途：

进行串行异步通信
构造IntentService

3、IntentService

1. IntentService是一个继承自Service的抽象类

2. 优点

相比于线程：由于是服务，优先级比线程高，更不容易被系统杀死。因此较适合执行一些高优先级的后台任务。
相比于普通Service：可自动创建子线程来执行任务，且任务执行完毕后自动退出。

3. 工作原理

IntentService内部封装了HandlerThread和Handler。

public abstract class IntentService extends Service {
    private volatile Looper mServiceLooper;
    @UnsupportedAppUsage
    private volatile ServiceHandler mServiceHandler;
    private String mName;
    private boolean mRedelivery;

    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);
        }
    }

    public IntentService(String name) {
        super();
        mName = name;
    }

    public void setIntentRedelivery(boolean enabled) {
        mRedelivery = enabled;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

    @Override
    public void onStart(@Nullable Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }

    @Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }

    @Override
    public void onDestroy() {
        mServiceLooper.quit();
    }

    @Override
    @Nullable
    public IBinder onBind(Intent intent) {
        return null;
    }

    @WorkerThread
    protected abstract void onHandleIntent(@Nullable Intent intent);
}

工作原理
1、在IntentService.onCreate()里创建一个Handle对象即HandlerThread，利用其内部的Looper会实例化一个ServiceHandler对象；
2、任务请求的Intent会被封装到Message并通过ServiceHandler发送给Looper的MessageQueue，最终在HandlerThread中执行；
3、在ServiceHandler.handleMessage()中会调用IntentService.onHandleIntent()，可在该方法中处理后台任务的逻辑。

工作原理

三、Android中的线程池

1、优点

重用线程池中的线程，避免线程的创建和销毁带来的性能消耗；
有效控制线程池的最大并发数，避免大量的线程之间因互相抢占系统资源而导致阻塞现象；
进行线程管理，提供定时/循环间隔执行等功能。

2、线程池实现

线程池的概念来源：Java中的Executor，它是一个接口。
线程池的真正实现：ThreadPoolExecutor，提供一系列参数来配置线程池。

ThreadPoolExecutor构造方法

//构造参数
public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {

1. corePoolSize：核心线程数

默认情况下，核心线程会在线程中一直存活。
当设置ThreadPoolExecutor的allowCoreThreadTimeOut属性为
true：表示核心线程闲置超过超时时长，会被回收；
false：表示核心线程不会被回收，会在线程池中一直存活。

2. maximumPoolSize：最大线程数

当活动线程数达到这个数值后，后续的任务将会被阻塞。

3. keepAliveTime：非核心线程超时时间

超过这个时长，闲置的非核心线程就会被回收。
当设置ThreadPoolExecutor的allowCoreThreadTimeTout属性为true时，keepAliveTime对核心线程同样有效。

4. unit：用于指定keepAliveTime参数的时间单位

单位有：TimeUnit.MILLISECONDS、TimeUnit.SECONDS、TimeUnit.MINUTES等；

5. workQueue：任务队列

通过线程池的execute()方法提交的Runnable对象会存储在这个参数中。

6. threadFactory：线程工厂，可创建新线程

是个接口，只有一个方法Thread newThread(Runnable r)。

7. handler：在线程池无法执行新任务时进行调度。

所谓拒绝策略，就是当线程池满了、队列也满了的时候，我们对任务采取的措施。或者丢弃、或者执行、或者其他...
jdk自带4种拒绝策略：

CallerRunsPolicy // 在调用者线程执行
AbortPolicy // 直接抛出RejectedExecutionException异常
DiscardPolicy // 任务直接丢弃，不做任何处理
DiscardOldestPolicy // 丢弃队列里最旧的那个任务，再尝试执行当前任务

ThreadPoolExecutor的默认工作策略：
1、若程池中的线程数量未达到核心线程数，则会直接启动一个核心线程执行任务。
2、若线程池中的线程数量已达到或者超过核心线程数量，则任务会被插入到任务列表等待执行。
3、若任务无法插入到任务列表中，往往由于任务列表已满，此时如果
线程数量未达到线程池最大线程数，则会启动一个非核心线程执行任务；
4、线程数量已达到线程池规定的最大值，则拒绝执行此任务，ThreadPoolExecutor会调用RejectedExecutionHandler的rejectedExecution方法来通知调用者。

3、线程池分类

1. FixThreadPool：

含义：线程数量固定的线程池，所有线程都是核心线程，当线程空闲时不会被回收。
特点：能快速响应外界请求。

public class Executors {
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
}

2. CachedThreadPool：

含义：线程数量不定的线程池（最大线程数为Integer.MAX_VALUE），只有非核心线程，空闲线程有超时机制，超时回收。
特点：适合于执行大量的耗时较少的任务

public class Executors {
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
}

3. ScheduledThreadPool：

含义：核心线程数量固定，非核心线程数量不定。
特点：定时任务和固定周期的任务。

public class Executors {
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
}

4. SingleThreadExecutor：

含义：只有一个核心线程，可确保所有的任务都在同一个线程中按顺序执行。
特点：无需处理线程同步问题。

public class Executors {
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
}

4、线程池使用

1. 创建自定义线程池

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 10000, TimeUnit.MILLISECONDS, new LinkedBlockingDeque<Runnable>());

2. 提交任务

两种方式：execute()和submit()

executor.execute(() -> System.out.println("hello"));

Future<Long> future = executor.submit(() -> {
        System.out.println("task is executed");
        return System.currentTimeMillis();
    });
    System.out.println("task execute time is: " + future.get());

3. 关闭线程池

两种方式：shutdown()和shutdownNow()方法

shutdown()会将线程池状态置为SHUTDOWN，不再接受新的任务，同时会等待线程池中已有的任务执行完成再结束。
shutdownNow()会将线程池状态置为SHUTDOWN，对所有线程执行interrupt()操作，清空队列，并将队列中的任务返回回来。

4. 配置线程池的参数

根据任务的特性来分析：

任务的性质：CPU密集型、IO密集型和混杂型
任务的优先级：高中低
任务执行的时间：长中短
任务的依赖性：是否依赖数据库或者其他系统资源

使用技巧

如果任务属于CPU密集型，那么我们可以将线程池数量设置成CPU的个数，以减少线程切换带来的开销。如果任务属于IO密集型，我们可以将线程池数量设置得更多一些，比如CPU个数*2。

PS：我们可以通过Runtime.getRuntime().availableProcessors()来获取CPU的个数。

AsyncTask中THREAD_POOL_EXECUTOR线程池配置：
核心线程数 = cpu核心数 + 1；
线程池最大线程数 = cpu核心数*2 + 1；
核心线程无超时机制，非核心线程在闲置时超时时间为1秒；
任务队列的容量128；