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

一、主线程和子线程

1、概述

含义:线程是CPU调度的最小单元。
特点:线程是一种受限的系统资源。即线程不可无限制的产生且线程的创建和销毁都有一定的开销。
分类:
按用途可分为两类:
  1. 主线程:一般一个进程只有一个主线程,主要处理界面交互相关的逻辑。
  2. 子线程:除主线程之外都是子线程,主要用于执行耗时操作。
按形态可分为三类:
  1. AsyncTask:底层封装了线程池和Handler,便于执行后台任务以及在主线程中进行UI操作。
  2. HandlerThread:一种具有消息循环的线程,其内部可使用Handler。
  3. 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. 五个核心方法:
  1. onPreExecute():
    运行在:主线程
    调用时刻:在异步任务执行之前被调用
    作用:可用于进行一些界面上的初始化操作
  2. doInBackground(Params…params):
    运行在:子线程
    作用:可用于处理所有的耗时任务。若需要更新UI需调用 publishProgress(Progress...)方法
    注意:任务一旦完成就通过return语句将任务的执行结果返回,若Result被指定为void,就可不返回执行结果
  3. onProgressUpdate(Progress…values):
    运行在:主线程
    调用时刻:在后台任务中调用publishProgress(Progress...)之后该方法会被调用
    作用:可利用方法中携带的参数如Progress来对UI进行相应地更新
  4. onPostExecute(Result result):
    运行在:主线程
    调用时刻:在异步任务执行完毕并通过return语句返回时被调用
    作用:可利用方法中返回的数据来进行一些UI操作
  5. onCancelled():
    运行在:主线程
    调用时刻:当异步任务被取消时被调用
    作用:可用于做界面取消的更新

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

4. 开始和结束异步任务的方法:
  1. execute(Params...params)
    必须在主线程中调用
    作用:表示开始一个异步任务
    注意:一个异步对象只能调用一次execute()方法
  2. 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的使用
  1. 实例化一个HandlerThread对象,参数是该线程的名称;
  2. 通过 HandlerThread.start()开启线程;
  3. 实例化一个Handler并传入HandlerThread中的looper对象,使得与HandlerThread绑定;
  4. 利用Handler即可执行异步任务;
  5. 当不需要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()方法

  1. shutdown()会将线程池状态置为SHUTDOWN,不再接受新的任务,同时会等待线程池中已有的任务执行完成再结束。
  2. 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;

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 203,937评论 6 478
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 85,503评论 2 381
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 150,712评论 0 337
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 54,668评论 1 276
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 63,677评论 5 366
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 48,601评论 1 281
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 37,975评论 3 396
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 36,637评论 0 258
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 40,881评论 1 298
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,621评论 2 321
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,710评论 1 329
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 33,387评论 4 319
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 38,971评论 3 307
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,947评论 0 19
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,189评论 1 260
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 44,805评论 2 349
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 42,449评论 2 342

推荐阅读更多精彩内容