android：线程池和AsyncTask使用小结

• 3.1版本之后系统，默认是使用SERIAL_EXECUTOR串行任务执行，

• 可以预料到异步任务将会是一个个顺序执行

• 一个个线程按加入顺序同步执行的。也就是说，线程池中只有一个核心线程在工作，

• 其他线程都要等之前的线程执行完才能执行

*/

private void initExecute() {

String url = “http://blog.csdn.net/huangxiaoguo1”;

task = new MyAsyncTask().execute(url);

}

/**

• 自定义线程池执行，仅支持3.1以上系统

• 使用默认提供的AsyncTask.THREAD_POOL_EXECUTOR线程池

• 最大并发执行5个线程，后面的线程都只能等之前5个结束之后再执行

*/

private void initExecuteOnExecutor() {

String url = “http://blog.csdn.net/huangxiaoguo1”;

task = new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, url);

}

/**

• 自定义线程池,

• 10个核心任务并发执行，而且缓存队列最多能够存储100个任务，

• 当队列满了之后还可以创建10个运行线程

• corePoolSize 核心线程池大小

• maximumPoolSize 线程池最大容量大小

• keepAliveTime 线程池空闲时，线程存活的时间

• TimeUnit 时间单位

• ThreadFactory 线程工厂

• BlockingQueue任务队列

• RejectedExecutionHandler 线程拒绝策略

*/

private void initMyExecute() {

String url = “http://blog.csdn.net/huangxiaoguo1”;

Executor myExecutor = new ThreadPoolExecutor(5, 50, 10,

TimeUnit.SECONDS, new LinkedBlockingDeque(100));

//ExecutorService executorService = Executors.newFixedThreadPool(3);

/**

• myExecutor也可以为newCachedThreadPool，newFixedThreadPool，

• newScheduledThreadPool，newSingleThreadExecutor

*/

task = new MyAsyncTask().executeOnExecutor(myExecutor, url);

}

public class MyAsyncTask extends AsyncTask<String, Integer, StringBuilder> {

/**

• 在execute(Params… params)被调用后立即执行，

• 一般用来在执行后台任务前对UI做一些标记。(准备工作)

*/

@Override

protected void onPreExecute() {

//后台执行先回调

super.onPreExecute();

progressDialog.show();

}

/**

• 在onPreExecute()完成后立即执行，用于执行较为费时的操作，

• 此方法将接收输入参数和返回计算结果。

• 在执行过程中可以调用publishProgress(Progress… values)来更新进度信息。(主线程中执行

• @param strings

• @return

*/

@Override

protected StringBuilder doInBackground(String… strings) {//对应第一个参数

//后台处理操作，不能修改UI

if (isCancelled())//Task被取消了，马上退出循环

return null;

try {

URL url = new URL(strings[0]);

HttpURLConnection conn = (HttpURLConnection) url.openConnection();

conn.setRequestMethod(“GET”);

conn.setReadTimeout(30000);

conn.setConnectTimeout(30000);

int code = conn.getResponseCode();

if (code == 200) {

InputStream inputStream = conn.getInputStream();

InputStreamReader inputReader = new InputStreamReader(inputStream);

BufferedReader reader = new BufferedReader(inputReader);

StringBuilder stringBuilder = new StringBuilder();

while (true) {

String readLine = reader.readLine();

if (readLine != null) {

stringBuilder.append(readLine);

} else {

break;

}

}

reader.close();

inputReader.close();

conn.disconnect();

return stringBuilder;

}

} catch (MalformedURLException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

return null;//对应第三个参数

}

/**

• 在调用publishProgress(Progress… values)时，此方法被执行，直接将进度信息更新到UI组件上。

• (主线程中执行,当后台任务的执行进度发送改变时此方法会被调用).

• @param values

*/

@Override

protected void onProgressUpdate(Integer… values) {//对应第二个参数

//后台任务,不能直接修改UI

super.onProgressUpdate(values);

if (isCancelled()) //Task被取消了，不再继续执行后面的代码

return;

progressDialog.setProgress(values[0]);

}

/**

• 当后台操作结束时，此方法将会被调用，计算结果将做为参数传递到此方法中，

• 直接将结果显示到UI组件上。(异步执行后这个方法被调用)

• @param s

*/

@Override

protected void onPostExecute(StringBuilder s) {//对应第三个参数

//后台任务完成后回调，更新UI

super.onPostExecute(s);

if (isCancelled()) //Task被取消了，不再继续执行后面的代码

return;

progressDialog.dismiss();

if (s != null)

mTextView.setText(s);

}

@Override

protected void onCancelled() {

//取消时回调

progressDialog.dismiss();

super.onCancelled();

}

// @Override

// protected void onCancelled(String s) {//对应第三个参数

// super.onCancelled(s);

// }

}

@Override

protected void onDestroy() {

//取消异步任务代码

if (task != null && task.getStatus() == AsyncTask.Status.RUNNING) {

task.cancel(true);

}

super.onDestroy();

}

}

线程池

---

线程池一、newFixedThreadPool

package tsou.cn.threadtest;

import android.os.Bundle;

import android.os.SystemClock;

import android.support.v7.app.AppCompatActivity;

import android.util.Log;

import android.view.View;

import android.widget.Button;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

/***

• newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待

• 每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。

• 线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，

• 那么线程池会补充一个新线程。

*/

public class NewFixedThreadPoolActivity extends AppCompatActivity implements View.OnClickListener {

/**

• 开始

*/

private Button mStart;

private ExecutorService fixedThreadPool;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_btn);

initData();

initView();

}

private void initData() {

fixedThreadPool = Executors.newFixedThreadPool(3);

}

private void initView() {

mStart = (Button) findViewById(R.id.start);

mStart.setOnClickListener(this);

}

@Override

public void onClick(View v) {

switch (v.getId()) {

default:

break;

case R.id.start:

for (int i = 0; i < 20; i++) {

final int m = i;

fixedThreadPool.execute(new Runnable() {

@Override

public void run() {

/**

• 因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。

定长线程池的大小最好根据系统资源进行设置。

*/

if (fixedThreadPool.isShutdown()) {

return;

}

Log.e(“huangxiaoguo”, “huangxiaoguo” + m);

SystemClock.sleep(2000);

}

});

}

break;

}

}

/**

• 停止线程工作

*/

@Override

protected void onDestroy() {

super.onDestroy();

//threadPool 不能为空 threadPool 没有崩溃 threadPool 没有停止

if (fixedThreadPool != null && !fixedThreadPool.isShutdown()

&& !fixedThreadPool.isTerminated()) {

fixedThreadPool.shutdownNow();

}

}

}

线程池二、newScheduledThreadPool

package tsou.cn.threadtest;

import android.os.Bundle;

import android.support.v7.app.AppCompatActivity;

import android.util.Log;

import android.view.View;

import android.widget.Button;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

/**

• 创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

*/

public class NewScheduledThreadPoolActivity extends AppCompatActivity implements View.OnClickListener {

/**

• 开始

*/

private Button mStart;

private ScheduledExecutorService scheduledThreadPool;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_btn);

initData();

initView();

}

private void initData() {

scheduledThreadPool = Executors.newScheduledThreadPool(3);

}

private void initView() {

mStart = (Button) findViewById(R.id.start);

mStart.setOnClickListener(this);

}

@Override

public void onClick(View v) {

switch (v.getId()) {

default:

break;

case R.id.start:

// initPoolOne();

// initPoolTwo();

initPoolThree();

break;

}

}

/**

• 表示延迟2秒后每3秒执行一次

*/

private void initPoolThree() {

scheduledThreadPool.scheduleWithFixedDelay(new Runnable() {

@Override

public void run() {

if (scheduledThreadPool.isShutdown()) {

return;

}

Log.e(“huangxiaoguo”, “huangxiaoguo”);

}

}, 2, 3, TimeUnit.SECONDS);

}

/**

• 表示延迟2秒后每3秒执行一次

*/

private void initPoolTwo() {

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {

@Override

public void run() {

if (scheduledThreadPool.isShutdown()) {

return;

}

Log.e(“huangxiaoguo”, “huangxiaoguo”);

}

}, 2, 3, TimeUnit.SECONDS);

}

/**

• 表示延迟2秒后执行

*/

private void initPoolOne() {

scheduledThreadPool.schedule(new Runnable() {

@Override

public void run() {

if (scheduledThreadPool.isShutdown()) {

return;

}

Log.e(“huangxiaoguo”, “huangxiaoguo”);

}

}, 2, TimeUnit.SECONDS);

}

/**

• 停止线程工作

*/

@Override

protected void onDestroy() {

super.onDestroy();

//threadPool 不能为空 threadPool 没有崩溃 threadPool 没有停止

if (scheduledThreadPool != null && !scheduledThreadPool.isShutdown()

&&!scheduledThreadPool.isTerminated()) {

scheduledThreadPool.shutdownNow();

}

}

}

线程池三、newCachedThreadPool

package tsou.cn.threadtest;

import android.os.Bundle;

import android.os.SystemClock;

import android.support.v7.app.AppCompatActivity;

import android.util.Log;

import android.view.View;

import android.widget.Button;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

/**

• 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

• 如果线程池的大小超过了处理任务所需要的线程，

• 那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，

• 此线程池又可以智能的添加新线程来处理任务。

• 此线程池不会对线程池大小做限制，

• 线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

*/

public class NewCachedThreadPoolActivity extends AppCompatActivity implements View.OnClickListener {

/**

• 开始

*/

private Button mStart;

private ExecutorService cachedThreadPool;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_btn);

initData();

initView();

}

private void initData() {

cachedThreadPool = Executors.newCachedThreadPool();

}

private void initView() {

mStart = (Button) findViewById(R.id.start);

mStart.setOnClickListener(this);

}

@Override

public void onClick(View v) {

switch (v.getId()) {

default:

break;

case R.id.start:

for (int i = 0; i < 20; i++) {

final int m = i;

cachedThreadPool.execute(new Runnable() {

@Override

public void run() {

SystemClock.sleep(2000);

if (cachedThreadPool.isShutdown()) {

return;

}

Log.e(“huangxiaoguo”, “huangxiaoguo” + m);

}

});

}

break;

}

}

/**

• 停止线程工作

*/

@Override

protected void onDestroy() {

super.onDestroy();

//threadPool 不能为空 threadPool 没有崩溃 threadPool 没有停止

if (cachedThreadPool != null && !cachedThreadPool.isShutdown()

&&!cachedThreadPool.isTerminated()) {

cachedThreadPool.shutdownNow();

}

}

}

线程池四、newSingleThreadExecutor

package tsou.cn.threadtest;

import android.os.Bundle;

import android.os.SystemClock;

import android.support.v7.app.AppCompatActivity;

import android.util.Log;

import android.view.View;

import android.widget.Button;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

/**

• 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，

• 保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行

• 这个线程池只有一个线程在工作，也就是相当于单线程串行执行>所有任务。

• 如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。

• 此线程池>保证所有任务的执行顺序按照任务的提交顺序执行。

*/

public class NewSingleThreadExecutorActivity extends AppCompatActivity implements View.OnClickListener {

/**

• 开始

*/

private Button mStart;

private ExecutorService singleThreadExecutor;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_btn);

initData();

initView();

}

private void initData() {

singleThreadExecutor = Executors.newSingleThreadExecutor();

}

private void initView() {

mStart = (Button) findViewById(R.id.start);

mStart.setOnClickListener(this);

}

@Override

public void onClick(View v) {

switch (v.getId()) {

default:

break;

case R.id.start:

for (int i = 0; i < 20; i++) {

final int m = i;

singleThreadExecutor.execute(new Runnable() {

@Override

public void run() {

SystemClock.sleep(2000);

if (singleThreadExecutor.isShutdown()) {

return;

}

Log.e(“huangxiaoguo”, “huangxiaoguo” + m);

}

});

}

break;

}

}

/**

• 停止线程工作

*/

@Override

protected void onDestroy() {

super.onDestroy();

//threadPool 不能为空 threadPool 没有崩溃 threadPool 没有停止

if (singleThreadExecutor != null && !singleThreadExecutor.isShutdown()

&& !singleThreadExecutor.isTerminated()) {

singleThreadExecutor.shutdownNow();

}

}

}

自定义线程池工具类（代码中有详细注释）

---

创建线程池管理类

package tsou.cn.threadtest.manager;

import android.annotation.SuppressLint;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.LinkedBlockingDeque;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

/**

• 线程池管理

• @author huangxiaoguo

*/

public class ThreadPoolManager {

private ThreadPoolManager() {

}

// 饿汉式 线程安全

private static ThreadPoolManager instance = new ThreadPoolManager();

private PoolProxy longPoolProxy; // 给联网使用的线程池

private PoolProxy shortPoolProxy; // 读写文件使用的线程池

public static ThreadPoolManager getInstance() {

return instance;

}

// 联网

// 读写文件

// 效率最高 cpu 核心数 *2+1

// 1 *2+1

public PoolProxy createLongThreadPool() {

if (longPoolProxy == null) {

longPoolProxy = new PoolProxy(5, 5, 5000);

}

return longPoolProxy;

}

public PoolProxy createShortThreadPool() {

if (shortPoolProxy == null) {

shortPoolProxy = new PoolProxy(3, 3, 5000);

}

return shortPoolProxy;

}

/**

• 配置线程池 代理类 ThreadPoolExecutor 线程池

• @author wxj

*/

public class PoolProxy {

private int corePoolSize;

private int maximumPoolSize;

private long time;

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此我收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

// 联网

// 读写文件

// 效率最高 cpu 核心数 *2+1

// 1 *2+1

public PoolProxy createLongThreadPool() {

if (longPoolProxy == null) {

longPoolProxy = new PoolProxy(5, 5, 5000);

}

return longPoolProxy;

}

public PoolProxy createShortThreadPool() {

if (shortPoolProxy == null) {

shortPoolProxy = new PoolProxy(3, 3, 5000);

}

return shortPoolProxy;

}

/**

• 配置线程池 代理类 ThreadPoolExecutor 线程池

• @author wxj

*/

public class PoolProxy {

private int corePoolSize;

private int maximumPoolSize;

private long time;

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此我收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-8FLtQYtz-1715498300261)]

[外链图片转存中…(img-qu1DYkPZ-1715498300263)]

[外链图片转存中…(img-cCDg3h1o-1715498300265)]

[外链图片转存中…(img-3TXxxuHV-1715498300266)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！