AsyncTaks的内部实现机制相信已经很多人了解过了,但是多次调用excute()后,它是怎么执行的?带着这个疑问,来实践下看看
public class TestActivity extends AppCompatActivity {
private static int ID = 0;
private static final int TASK_COUNT = 20;
private static ExecutorService SINGLE_TASK_EXECUTOR;
private static ExecutorService FIXED_TASK_EXECUTOR;
private static ExecutorService Cached_TASK_EXECUTOR;
//自定义的3个线程池
static {
SINGLE_TASK_EXECUTOR = Executors.newSingleThreadExecutor();
FIXED_TASK_EXECUTOR = Executors.newFixedThreadPool(7);
Cached_TASK_EXECUTOR = Executors.newCachedThreadPool();
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_test);
final ListView taskList = findViewById(R.id.task_list);
taskList.setAdapter(new AsyncTaskAdapter(getApplication(), TASK_COUNT));
}
//List的适配器
private class AsyncTaskAdapter extends BaseAdapter {
private Context mContext;
private LayoutInflater mFactory;
private int mTaskCount;
List<SimpleAsyncTask> mTaskList;
public AsyncTaskAdapter(Context context, int taskCount) {
mContext = context;
mFactory = LayoutInflater.from(mContext);
mTaskCount = taskCount;
mTaskList = new ArrayList<>(taskCount);
}
@Override
public int getCount() {
return mTaskCount;
}
@Override
public Object getItem(int position) {
return mTaskList.get(position);
}
@Override
public long getItemId(int position) {
return position;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
if (convertView == null) {
convertView = mFactory.inflate(R.layout.asynctask_demo_item, null);
SimpleAsyncTask task = new SimpleAsyncTask(convertView);
task.executeOnExecutor(SINGLE_TASK_EXECUTOR);
mTaskList.add(task);
}
return convertView;
}
}
private class SimpleAsyncTask extends AsyncTask<Void, Integer, Void> {
private TaskItem mTaskItem;
private String mName;
public SimpleAsyncTask(View item) {
mTaskItem = (TaskItem) item;
mName = "Task #" + String.valueOf(++ID);
}
@Override
protected void onPreExecute() {
mTaskItem.setTitle(mName);
}
@Override
protected Void doInBackground(Void... params) {
int prog = 1;
while (prog < 101) {
SystemClock.sleep(50);
publishProgress(prog);
prog++;
}
return null;
}
@Override
protected void onPostExecute(Void result) {
}
@Override
protected void onProgressUpdate(Integer... values) {
mTaskItem.setProgress(values[0]);
}
}
}
class TaskItem extends LinearLayout {
private TextView mTitle;
private ProgressBar mProgress;
public TaskItem(Context context) {
super(context);
}
public TaskItem(Context context, AttributeSet attrs) {
super(context, attrs);
}
public TaskItem(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
public void setTitle(String title) {
if (mTitle == null) {
mTitle = findViewById(R.id.task_name);
}
mTitle.setText(title);
}
public void setProgress(int prog) {
if (mProgress == null) {
mProgress = findViewById(R.id.task_progress);
}
mProgress.setProgress(prog);
}
}
下面是xml代码:
activity_test:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context="com.hao.Demo.TestActivity">
<ListView
android:id="@+id/task_list"
android:layout_width="match_parent"
android:layout_height="match_parent">
</ListView>
</LinearLayout>
asynatask_demo_item.xml
<com.hao.Demo.TaskItem xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="horizontal">
<TextView
android:id="@+id/task_name"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Task #"/>
<ProgressBar
android:id="@+id/task_progress"
android:layout_width="match_parent"
android:layout_height="wrap_content"
style="?android:attr/progressBarStyleHorizontal" />
</com.ryg.chapter_2.TaskItem>
当执行task.execute()也就是AsyncTask默认的执行方法时,可以看到只启动一个线程执行
下面接着调用
task.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR);
然后会发现和上面的一样
那再换一个
task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
这个时候会发现同时启动了两个,说下线程池的CorePool为2个,具体CorePool是多少个在下面看源码才会知道
那下面切换到用自定义的线程池
private static ExecutorService SINGLE_TASK_EXECUTOR;
private static ExecutorService FIXED_TASK_EXECUTOR;
private static ExecutorService Cached_TASK_EXECUTOR;
static {
SINGLE_TASK_EXECUTOR = Executors.newSingleThreadExecutor();
FIXED_TASK_EXECUTOR = Executors.newFixedThreadPool(7);
Cached_TASK_EXECUTOR = Executors.newCachedThreadPool();
}
task.executeOnExecutor(SINGLE_TASK_EXECUTOR);
发现是单线程执行;
task.executeOnExecutor(FIXED_TASK_EXECUTOR);
这里按照定义的7个线程执行
task.executeOnExecutor(Cached_TASK_EXECUTOR);
这个也是按照定义来执行。
下面来看源码里线程是怎么创建的,首先来看THREAD_POOL_EXECUTOR
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE_SECONDS = 30;
可以看到Core_POOL_Size是根据CPU_COUNT的,也就是根据CPU核心数来计算,我的模拟器开的2核,所以是2个线程
//这个是THREAD_POOL_EXECUTOR要用的ThreadFactory,相当于计数的作用,使用了原子类
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());
}
};
/**
* 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;
}
注释写的很清楚,是并行执行task,本质上就是新建了个线程池
下面来看SERIAL_EXECUTOR,我把关键代码提取出来了
当直接调用execute()方法时,会执行sDefaultExecutor也就是串行线程池
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static class SerialExecutor implements Executor {
// ArrayDuque双端队列存储Runnable
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
// 新建Runnable调用传入的r的run并添加到mTasks队列中,调用scheduleNext()。
// 发现,,,这自己根本就没执行嘛,就是向多个要执行的任务放入队列中从而可以串行按序执行
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
// 可以看到使用了THREAD_POOL_EXECUTOR来执行
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
发现SerialExecutor 本质上是将多个要执行的任务进行串行处理,是线性调度的线程池,它本身并不执行任务,而是交给THREAD_POOL_EXECUTOR并行线程池去处理,执行完一个后再poll一个;
但是这样也有他的好处,保证了任务是有序完成的,如果直接并行并不能保证按序完成。