android 中的线程和线程池

原创 于 2018-11-13 15:09:43 发布 · 142 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

           在android中除了传统的Thread以外，还包含AsyncTask、HandlerThread以及IntentService,这三者的底层实现也是线程，但是它们具有特殊的表现形式，同时在使用上也各有优缺点。下面我们一起来分析一下

 

AsyncTask

             AsyncTask是一种轻量级的异步任务类，它可以在线程池中执行后台任务，然后把执行的进度和最终的结果传递给主线程并在主线程中更新UI，通过AsyncTask可以更加方便地执行后台任务以及在主线程中访问UI,但是AsyncTask并不适合进行特别耗时的后台任务，对于特别耗时的任务来说，建议使用线程池。

new AsyncTask<String,String,String>(){

            // 在主线程中执行，在异步任务开始之前执行调用
            // 可以做一些准备工作
            @Override
            protected void onPreExecute() {
                super.onPreExecute();
            }

            // 在线程池中执行，此方法用于执行异步任务
            // 返回计算结果给onPostExecute方法
            @Override
            protected String doInBackground(String... strings) {
                // 更新任务进度， publishProgress()方法会调用onProgressUpdate()方法
                publishProgress();
                return null;
            }

            // 在主线程中执行，当后台任务的执行进度发生改变时此方法会被调用
            @Override
            protected void onProgressUpdate(String... values) {
                super.onProgressUpdate(values);
            }

            // 在主线程中执行，在异步任务执行之后，此方法会被调用
            // s是后台的返回值
            @Override
            protected void onPostExecute(String s) {
                super.onPostExecute(s);
            }
        };

上面的这几个方法，onPreExecute()先执行，接着是doInBackground,最后才是onPostExecute。除了这四个方法外，AsyncTask还提供了onCancelled()方法，它同样在主线程中执行，当异步任务被取消时，onCancelled()方法会被调用，这个时候onPostExecute则不会被调用。下面我们通过源码来看看，首先分析execute()方法

@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    return executeOnExecutor(sDefaultExecutor, params);
}

@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
        Params... params) {
    if (mStatus != Status.PENDING) {
        switch (mStatus) {
            case RUNNING:
                throw new IllegalStateException("Cannot execute task:"
                        + " the task is already running.");
            case FINISHED:
                throw new IllegalStateException("Cannot execute task:"
                        + " the task has already been executed "
                        + "(a task can be executed only once)");
        }
    }

    mStatus = Status.RUNNING;
    // 最先执行
    onPreExecute();

    mWorker.mParams = params;
    // 线程池开始执行
    exec.execute(mFuture);

    return this;
}

我们来分析这行  exec.execute(mFuture);

exec是一个接口Executor,那么我们需要找到它的具体实现类。在AsyncTask类的上面有这两行代码

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

其中sDefaultExecutor实际上是一个串行的线程池，一个进程中所有的AsyncTask全部在这个串行的线程池中排队执行，所以最终会执行到SerialExecutor类中的execute()方法

 private static class SerialExecutor implements Executor {
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        Runnable mActive;

        public synchronized void execute(final Runnable r) {
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        r.run();
                    } finally {
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                scheduleNext();
            }
        }

        protected synchronized void scheduleNext() {
            if ((mActive = mTasks.poll()) != null) {
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

总结一下：

1.首先系统会把AsyncTask的Params参数封装为FutureTask对象，在这里FutureTask充当了Runnable的作用

2.接着这个FutureTask会交给SerialExecutor的execute方法去处理

3.SerialExecutor的execute方法首先会把FutureTask对象插入到任务队列mTasks中，如果这个时候没有正在活动的AsyncTask任务，那么会调用SerialExecutor的scheduleNext方法来执行下一个AsyncTask任务。同时当一个AsyncTask任务执行完毕后，AsyncTask会继续执行其他任务直到所有的任务都被执行为止

 

那么接下来我们看看AsyncTask的构造方法里面做了什么呢？

public AsyncTask() {
    this((Looper) null);
}

public AsyncTask(@Nullable Looper callbackLooper) {
        // 省略代码
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
                Result result = null;
                try {
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    //noinspection unchecked
		    // 执行doInBackground
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
		    // 最后执行doInBackground
                    postResult(result);
                }
                return result;
            }
        };

        // 省略代码
}

private Result postResult(Result result) {
    @SuppressWarnings("unchecked")
    Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
            new AsyncTaskResult<Result>(this, result));
    message.sendToTarget();
    return result;
}


private static class InternalHandler extends Handler {
        public InternalHandler(Looper looper) {
            super(looper);
        }

        @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
        @Override
        public void handleMessage(Message msg) {
            AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
            switch (msg.what) {
                case MESSAGE_POST_RESULT:                
                    result.mTask.finish(result.mData[0]);
                    break;
                case MESSAGE_POST_PROGRESS:
                    result.mTask.onProgressUpdate(result.mData);
                    break;
        }
    }
}

private void finish(Result result) {
    if (isCancelled()) {
        onCancelled(result);
    } else {
        onPostExecute(result);
    }
    mStatus = Status.FINISHED;
}

在mWorker的call方法中，首先将mTaskInvoked设为true,表示当前任务已经被调用过了，然后执行AsyncTask的doInBackground方法，在最后执行postResult()方法。而在postResult()中通过Handler将最终的结果交给onPostExecute()处理，到这里AsyncTask就分析完了。

 

HandlerThread

HandlerThread继承了Thread，它是一种可以使用Handler的Thread

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

使用起来也很简答

 private void initThread() { 
       mHandlerThread = new HandlerThread("check-message-coming"); 
       mHandlerThread.start(); 
       mThreadHandler = new Handler(mHandlerThread.getLooper()) { 
	    @Override 
	    public void handleMessage(Message msg) { 
	       update();//模拟数据更新 
	       if (isUpdateInfo) 
	       mThreadHandler.sendEmptyMessage(MSG_UPDATE_INFO); 
	    } 
       }; 
}

相比较于普通的Thread而言，HandlerThread具有发送消息的功能，使得它变的更为好用

 

IntentService

IntentService是一种特殊的Service,它继承了Service并且它是一个抽象类，因此必须创建它的子类才能使用IntentService。IntentService可用于执行后台耗时的任务，当任务执行后它会自动停止，同时由于IntentService是服务的原因，这导致它的优先级比单纯的线程要高很多，所以IntentService比较适合执行一些高优先级的后台任务，因为它优先级高不容易被系统杀死。

首先在onCreate()方法中封装了HandlerThread和Handler

@Override
public void onCreate() {
        // TODO: It would be nice to have an option to hold a partial wakelock
        // during processing, and to have a static startService(Context, Intent)
        // method that would launch the service & hand off a wakelock.

        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

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

当IntentService被第一次启动时，会执行onCreate方法，在onCreate方法会创建一个HandlerThread，然后使用它的Looper来构造一个Handler对象mServiceHandler,这样通过mServiceHandler发送的消息最终都会在HandleThread中执行，最终执行到onHandlerIntent()方法中

 

Android中的线程池

优点：

（1）重用线程池中的线程，避免因为线程的创建和销毁所带来的性能开销

（2）能有效的控制线程池的最大并发数，避免大量的线程之间因互相抢占系统资源而导致的阻塞现象

（3）能够对线程进行简单的管理，并提供定时执行以及指定间隔循环执行等功能

 

Android中的线程池的概念来源于Java中的Executor,Executor是一个接口，真正的线程池的实现为ThreadPoolExecutor,ThreadPoolExecutor提供了一系列参数来配置线程池，通过不同的参数可以创建不同的线程池，那么我们先来看看ThreadPoolExecutor

这是ThreadPoolExecutor的一个比较常用的构造方法，我们先来看看它的构造方法里面各个参数的含义

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
}
​

corePoolSize

线程池的核心线程数，默认情况下，核心线程会在线程池中一直存活，即使它们处于闲置状态。如果将ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true,那么闲置的核心线程在等待新任务到来时会有超时策略，这个时间间隔由keepAliveTime所指定，当等待时间超过keepAliveTime所指定的时长后，核心线程就会被终止。

 

maximumPoolSize

线程池所能容纳的最大线程数，当活动线程数达到这个数值后，后续的新任务将会被阻塞

 

keepAliveTime

非核心线程闲置时的超时时长，超过这个时长，非核心线程就会被回收。当ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true时，keepAliveTime同样会作用于核心线程。

 

unit

用于指定keepAliveTime参数的时间单位，这是一个枚举，常用的有TimeUnit.MILLISECONDS(毫秒)，TimeUnit.SECONDS(秒)以及TimeUnit.MINUTES(分钟)等

 

workQueue

线程池中的任务队列，通过线程池的execute方法提交的Runnable对象会存储在这个参数中

 

threadFactory

线程工厂，为线程池提供创建新线程的功能。ThreadFactory是一个接口，它只有一个方法：Thread  newThread(Runnable r)

 

除了上面的这些参数外，ThreadPoolExecutor还有一个不常用的参数RejectedExecutionHandler。当线程池无法执行新任务时，这可能是由于任务队列已满或者是无法成功执行任务。这个时候ThreadPoolExecutor会调用handler的rejectedExecution方法来通知调用者

 

 

 

ThreadPoolExecutor执行任务时大致遵循如下规则：

（1） 如果线程池中的线程数量未超过核心线程的数量，那么会直接启动核心线程来执行任务

（2） 如果线程池中的线程数量已经达到或者超过核心线程数量，那么任务会被插入到任务队列中排队等待执行

（3）当任务无法被插入到等待队列当中的时候，如果线程数量未达到线程池规定的最大值，那么会立刻启动一个非核心线程来执行任务；如果线程数量已经达到线程池中规定的最大值的话，那么就拒绝执行此任务，ThreadPoolExecutor会调用RejectedExecutionHandler的rejectedExecution方法来通知调用者

 

 

Android中线程池的分类

在android中我们有时候并不会直接使用ThreadPoolExecutor的，而是使用一些具有不同功能特性的线程池，它们都直接或者间接地通过配置ThreadPoolExecutor来实现自己的功能特性，常见的有以下几个：

public class Executors {

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


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


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

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

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

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

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

    public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }

}

在Executors类中可以找到这些代码，现在我们一起来分析一下

1.FixedThreadPool

线程数量固定的线程池，当线程处于空闲状态时，它们并不会被回收，除非线程池被关闭了。当所有的线程都处于活动状态时，新任务都会处于等待状态，直到有线程空闲出来。由于FixedThreadPool只有核心线程并且这些核心线程不会被回收，所以它能够更加快速的响应外界的请求。注意，FixedThreadPool中只有核心线程并且这些核心线程没有超时机制，另外任务队列也是没有大小限制的

 

2.CachedThreadPool

线程数量不定的线程池，它只有非核心线程，并且最大线程数为Integer.MAX_VALUE。当线程池中的线程都处于一种活动状态时，线程池会创建新的线程来处理新任务，否则就会利用空闲的线程来处理新任务。线程池中的空闲线程都有超时时间，这个超时时间为60秒，超过60秒闲置线程就会被回收。需要注意的是，CachedThreadPool的任务队列其实是一个空集合，这将导致任何任务都会立即被执行，这类线程池适用于执行大量的耗时较少的任务

 

3.ScheduledThreadPool

核心线程数量固定，而非核心线程数量是没有限制的，并且当非核心线程闲置时会被立即回收。主要用于执行定时任务和具有固定周期的重复任务

 

4.SingleThreadExecutor

内部只有一个核心线程，确保所有的任务都在同一个线程中按顺序执行，SingleThreadExecutor的意义在于统一所有的外界任务到一个线程中按顺序执行，不需要处理线程同步的问题

 

当然线程池的种类绝对不止上面的这4种，在实际的开发过程中，你可以根据自己的需要去配置你所需要的线程池。到这里线程的知识就结束了，欢迎大家在下面留言

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值