android里的线程

android里的线程 AsyncTask(封装了Thread和Handler,采用了线程池),IntentService, HandlerThread和一些常用的线程池

• 线 程

1.AsyncTask
有采用线程池，封装了Thread和Handler

采用ThreadPoolExecutor线程池：

public abstract class AsyncTask<Params, Progress, Result>

  /**
     * An {@link Executor} that can be used to execute tasks in parallel.
     */
    public static final Executor THREAD_POOL_EXECUTOR;

    static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }

实际项目中怎么用AsyncTask？

**如图：模拟了一个下载文件的任务**

现在开始表演：

package com.yw.threaddemo;

import android.app.Dialog;
import android.app.ProgressDialog;
import android.content.Context;
import android.os.AsyncTask;
import android.view.View;
import android.widget.TextView;

/**
 * Created by yw on 17/10/25.
 * author jackyang
 * com.yw.threaddemo
 */
public class AsyncTaskDemo extends AsyncTask<String, Integer, String> {
    private Context mContext;
    private View mView;
    private Dialog mDialog;

    public AsyncTaskDemo(Context context, View view) {
        this.mContext = context;
        this.mView = view;
    }

    @Override
    protected void onPreExecute() {
        //在ui线程中执行，ps：先弹一个加载框 表示你正在处理
        super.onPreExecute();
        mDialog =
                new ProgressDialog(mContext);
        mDialog.setTitle("我是一个等待Dialog");
        mDialog.setCancelable(false);
        mDialog.show();
    }

    @Override
    protected void onPostExecute(String s) {
        //在ui线程中执行
        super.onPostExecute(s);
        mDialog.dismiss(); //关闭加载框
        ((TextView)mView).setText(s);
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        //当进度发生改变时，在ui线程中执行
        super.onProgressUpdate(values);
        //模拟 进度
        ((TextView)mView).setText("下载的进度是" + values[0] + "/10");
    }

    @Override
    protected void onCancelled(String s) {
        //在ui中执行，当任务被取消时执行
        super.onCancelled(s);
    }

    @Override
    protected String doInBackground(String... params) {
        //在子线程中执行 返回result onPostExecute得到回调的结果
        try {
           // Thread.sleep(10000); //模拟task
            for (int i = 0; i < 10; i++) {
                publishProgress(new Integer(i));
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "我是返回的数据";
    }
}

主线程里创建和执行task

 new AsyncTaskDemo(this, tv_show_result).execute("yw"); //创建和执行task

注意事项：

• AsyncTask必须在主线程里创建
• execute()必须在主线程里调用

源码下载地址

2.HandlerThread
继承Thread，可以使用handler的Thread；run()方法里会Looper.prepare()创建一个消息队列，并且开启消息循环Looper.loop();

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

3.IntentService
采用了HandlerThread

public abstract class IntentService extends Service
.
.
.
@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);
    .
    .
    .
}

来一个例子吧

首先实现一个具体的 Service

package com.yw.threaddemo;

import android.app.IntentService;
import android.content.Intent;
import android.util.Log;

/**
 * Created by yw on 17/10/25.
 * author jackyang
 * com.yw.threaddemo
 */
public class IntentServiceDemo extends IntentService {
    /**
     * Creates an IntentService.  Invoked by your subclass's constructor.
     *
     * @param name Used to name the worker thread, important only for debugging.
     */
    public IntentServiceDemo(String name) {
        super(name);
    }

    public IntentServiceDemo() {
        super("yw");
    }
    @Override
    protected void onHandleIntent(Intent intent) {
        String hint = intent.getStringExtra("hint");
        Log.d("yw", hint);
    }

    @Override
    public void onDestroy() {
        Log.d("yw", "onDestroy");
        super.onDestroy();
    }
}

然后在Activity里调用
startService(Intent intent)

  Intent i = new Intent(this, IntentServiceDemo.class);
        i.putExtra("hint", "666");
        startService(i);
        i.putExtra("hint", "777");
        startService(i);

log如下

从日志中看到onDestroy方法只执行了一次， why？

 * @see android.os.AsyncTask
 */
public abstract class IntentService extends Service {
    private volatile Looper mServiceLooper;
    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);   //源码中发现该方法，他会根据队列的里的服务是否都执行完了，再判断是否停止该服务
        }
    }
       .
       .
       .
}

demo下载地址

• 线程池

避免线程的重复创建和销毁，从而减小内存的消耗

1. ThreadPoolExecutor

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

1. FixedThreadPool

*Executors.class*

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

1. CachedThreadPool

*Executors.class*

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