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

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

线 程

1.AsyncTask

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

采用ThreadPoolExecutor线程池：

public abstract class AsyncTask

/** * 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 {

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下载地址

线程池

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

ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,

int maximumPoolSize,

long keepAliveTime,

TimeUnit unit,

BlockingQueue workQueue,

ThreadFactory threadFactory) {

this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,

threadFactory, defaultHandler);

}

FixedThreadPool

*Executors.class*

public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {

return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(), threadFactory);

}

CachedThreadPool

*Executors.class*

public static ExecutorService newCachedThreadPool() {

return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS, new SynchronousQueue());

}