一、主线程和子线程
1、概述
含义：线程是CPU调度的最小单元。
特点：线程是一种受限的系统资源。即线程不可无限制的产生且线程的创建和销毁都有一定的开销。
分类:
按用途可分为两类：
- 主线程：一般一个进程只有一个主线程，主要处理界面交互相关的逻辑。
- 子线程：除主线程之外都是子线程，主要用于执行耗时操作。
按形态可分为三类：
- AsyncTask：底层封装了线程池和Handler，便于执行后台任务以及在主线程中进行UI操作。
- HandlerThread：一种具有消息循环的线程，其内部可使用Handler。
- IntentService：是一种异步、会自动停止的服务，内部采用HandlerThread。
Q：如何避免频繁创建和销毁线程所带来的系统开销？
A：采用线程池，池中会缓存一定数量的线程，进而达到效果。Android 中的线程池来源于Java，主要通过Executor来派生特定类型的线程池。
二、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；
网友评论