Android线程

2016-09-14  本文已影响229人  wangsye

Android线程概述

线程分为主线程和子线程，主线程主要处理和界面相关的事情，子线程则往往用于处理耗时操作。

线程是操作系统最小的调度单元，同时线程又是一种受限的系统资源，即线程不可能无限制的产生，并且线程的创建和销毁都会有响应的开销。线程池会缓存一定数量的线程，通过线程池可以避免因为频繁创建和销毁线程所带来的系统开销。android中的线程池来源于Java,主要是通过Executor来派生特定类型的线程池。

主线程和子线程

主线程主要处理界面交互相关的逻辑，因为用户随时会和界面发生交互，因此主线程在任何时候都必须要有较高的响应速度，否则就会产生一种界面卡顿的感觉。

子线程，也叫工作线程，除了主线程以外的线程都叫子线程。

Android中的主线程也叫UI线程，作用是运行四大组件，以及处理它们和用户的交互。子线程执行耗时任务，比如网络请求，I/O操作等。

四种线程形态

Thread

最基本的线程使用方法，从Java继承而来。使用方法可以直接从Thread生成变量，或者使用Runnable初始化Thread。不再赘述。

AsyncTask

封装了线程池，和Handler，主要为了方便开发者在子线程中更新UI。

可以在线程池中执行后台任务，然后把执行的进度和最终的结果传递给主线程中更新UI。从实现上来说，AsyncTask封装了Thread和Handler，可以很方便的执行后台任务并更新UI。但是AsyncTask不适合进行特别耗时的任务，耗时任务建议使用线程池做。

四个核心方法

一些限制

工作原理

execute直接调用了executeOnExecutor，两个方法源代码如下:

public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
        //直接调用了executeOnExecutor方法。
}
 public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) {
            //此处保证一个AsyncTask只执行一次
        if (mStatus != Status.PENDING) {
            switch (mStatus) {
                case RUNNING:
                    throw new IllegalStateException(".....");
                case FINISHED:
                    throw new IllegalStateException("......");
            }
        }
        mStatus = Status.RUNNING;
        //调用onPreExecute，此时仍然在主线程上
        onPreExecute();
        mWorker.mParams = params;
        //在线程池上执行
        exec.execute(mFuture);
        return this;
    }

sDefaultExecutor是一个串行的线程池，sDefaultExecutor代码如下：

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
private static class SerialExecutor implements Executor {
            //保存需要执行的线程的队列
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        //当前正在执行的线程
        Runnable mActive;

        public synchronized void execute(final Runnable r) {
                //offer，想队列的尾部插入一个数据。
                //不能直接将参数的Runnable加入到队列中，因为在参数的run方法执行完之后执行scheduleNext方法，所以新建了一个Runnable对象，在新建的Runnable对象的run方法中直接执行了参数的run方法。
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        r.run();
                    } finally {
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                scheduleNext();
            }
        }

        protected synchronized void scheduleNext() {
                //获取头部的对象，并赋值给mActivie，如果不是null，则在线程池THREAD_POOL_EXECUTOR上执行。
            if ((mActive = mTasks.poll()) != null) {
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
   }

从上面的代码中可以看到AsyncTask是现行执行的。

AsyncTask有两个线程池，分别为sDefaultExecutor和THREAD_POOL_EXECUTOR，其中THREAD_POOL_EXECUTOR用来真正的执行AsyncTask，sDefaultExecutor用来做排队，保证AsyncTask顺序执行。

如何保证能够更新UI

AsyncTask有一个InternalHandler，其代码如下：

 private static class InternalHandler extends Handler {
         //构造函数，使用的Looper时主线程Looper，保证其处理消息是在主线程上。
        public InternalHandler() {
            super(Looper.getMainLooper());
        }

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

使用方法

  1. 生成AsncTask的对象，需要重写doInBackground，和onPostExecute方法。其中doInBackground方法是子线程需要执行的操作，onPostExecute表示子线程处理之后主线程需要执行的操作。如果需要可以重写onProgressUpdate方法，在主线程显示进度的变化。
  2. 执行AsyncTask的execute方法。

HandlerThread

是一种具有了消息循环的线程，在它的内部可以使用Handler。实现非常简单，就是在run方法中通过Looper.prepare来创建消息队列，通过loop方法开启消息循环，这样在实际的使用中就可以在HandlerThread中创建Handler了。其run方法如下：

@Override
    public void run() {
        mTid = Process.myTid();
        //创建消息队列
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        //开启消息循环
        Looper.loop();
        mTid = -1;
    }

HandlerThread有getLooper方法获取该线程对应的Looper，将次Looper传递给Handler就可以子线程中执行一些操作，比如主线程需要子线程执行网络请求，则可以通过Handler post一个Runnable即可，此Runnable会请求网络数据，数据请求完成之后将数据保存起来，或者将数据更新到UI（需要进行线程切换，比如使用主线程的handler来更新界面）。使用方法示例代码：

public class Activity1 extends Activity implement OnClickListener{
    //HandlerThread使用的Handler
    private Handler mHandler;
    private HandlerThread mHandlerThread;
    private Handler uiHandler = new Handler(){
        @override
         public void handleMessage(Message msg) {
         //处理消息
         //更新界面
         }
    };
    
    private Button btn;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btn = (Button) findViewById(R.id.btn);
        btn.setOnClickListener(this);
        mHandlerThread = new HandlerThread("Test");
        mHandlerThread.start();
        mHandler = new Handler(mHandlerThread.getLooper());
    }
    
    private Runnable mRunnable = new Runnable() {
        @Override
        public void run() {
          Log.d("MainActivity", "test HandlerThread...");
          try {
           //从网络请求数据
           getDataFromNetWork();
           //使用uiHandler执行一个post请求
           uiHandler.obtainMessage(1,"finished").sendToTarget();
           } catch (Exception e) {
               e.printStackTrace();
           }
        }
    };
    
    @Override
    public void onClick(View v) {
        switch(v.getId()) {
        case R.id.btn :
            mHandler.post(mRunnable);
            break;
        default :
            break;
        }
    }
    
    @Override
    protected void onDestroy() {
        mRunning = false;
        //移除回调
        mHandler.removeCallbacks(mRunnable);
        super.onDestroy();
    }
}

使用步骤:

  1. 声明Handler，HandlerThread对象。
  2. 生命Runnable对象
  3. 初始化HandlerThread对象， mHandlerThread = new HandlerThread("Test");
  4. HandlerThread启动，mHandlerThread.start();
  5. 初始化Handler对象，mHandler = new Handler(mHandlerThread.getLooper());
  6. 执行Runnable，mHandler.post(mRunnable);
  7. 在Runnable对象的run方法执行完毕后可以调用主线程的Handler，进行界面更新。

IntentService

是一个服务（Service），系统对其进行了封装使其可以更方便地执行后台任务，IntentService内部采用了HandlerThread来执行任务，当任务执行完毕之后IntentService会自动退出。作为一个服务，IntentService不容易被系统杀死从而可以尽量保证任务的执行。

IntentService是Service的子类，但它是一个抽象类，因此需要创建它的子类才能使用。其封装了HandlerThread和Handler。从其代码中可以看出其使用了HandlerThread。

    @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);
    }

Intent的处理

看其onStartCommand方法，onStartCommand掉哦那个onStart方法，而onStart的代码为：

    @Override
    public void onStart(Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        //直接调用了mServiceHandler发送消息，保证了消息在子线程中被调用。
        mServiceHandler.sendMessage(msg);
    }

ServiceHanlder对消息的处理如下:

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

        @Override
        public void handleMessage(Message msg) {
                //调用onHandleIntent处理消息
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);
        }
}

IntentService的onHandleIntent方法为一个抽象方法，需要子类重写。

protected abstract void onHandleIntent(Intent intent);

由于Looper是顺序执行任务的，因此IntentService也是顺序执行任务的。

线程池

线程池的优点

Android中得线程池来源于Java中的Executor，Executor是一个接口，真正的线程池的实现为ThreadPoolExecutor. ThreadPoolExecutor提供了一些列参数来配置线程池，根据不同的参数可以创建不同的线程池，从线程池的功能特性来说，Android的线程池主要有四类，通过Executors所提供的方法来得到。

ThreadPoolExecutor

ThreadPoolExecutor是线程池的真正实现，其构造方法提供了一系列参数来配置线程池。构造方法如下所示：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory)

除了上面的参数外还有一个参数，RejectedExecutionHandler，当线程池无法执行任务时会调用handler的rejectedExecution方法通知调用者。

规则

AsyncTask的线程池

  private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
  private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
  private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
  private static final int KEEP_ALIVE = 1;
  
  private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };
    
    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);

    public static final Executor THREAD_POOL_EXECUTOR
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

    /**
     * An {@link Executor} that executes tasks one at a time in serial
     * order.  This serialization is global to a particular process.
     */
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

从上面的代码可以知道AsyncTask对THREAD_POOL_EXECUTOR这个线程池进行了配置，最后的规则为：

线程池分类

上一篇下一篇

猜你喜欢

热点阅读