android：线程池和AsyncTask使用小结

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;

private ThreadPoolExecutor threadPool; // 线程池

public PoolProxy(int corePoolSize, int maximumPoolSize, long time) {

super();

this.corePoolSize = corePoolSize;

this.maximumPoolSize = maximumPoolSize;

this.time = time;

}

@SuppressLint(“NewApi”)

public void execute(Runnable r) {

/**

• 1.corePoolSize 初始化线程数量 2.maximumPoolSize 出了初始化 线程数量 另外最多 能创建的线程数量

• 3.keepAliveTime 如果没有任务 最多的存活时间 4. TimeUnit时间单位

*/

if (threadPool == null) { // 当线程池 为空的时候才去创建

threadPool = new ThreadPoolExecutor(corePoolSize,

maximumPoolSize, time, TimeUnit.MILLISECONDS,

new LinkedBlockingDeque(10));

}

// 就直接执行任务

threadPool.execute®;

}

/**

• 注意在需要取消任务的时候，不要使用shutdown(),或者shutdownNow();

• 来终止当前任务，因为你终止了当前任务，那样当前线程池还是存在的，

• 再向线程池提交任务的时候，可能会因为队列已满，出现RejectedExecutionException

• 所以使用remove方法移除当前任务来达到取消任务的效果，

• 获取时线程队列使用getQueue()方法

*/

最后

都说三年是程序员的一个坎，能否晋升或者提高自己的核心竞争力，这几年就十分关键。

技术发展的这么快，从哪些方面开始学习，才能达到高级工程师水平，最后进阶到Android架构师/技术专家？我总结了这 5大块；

我搜集整理过这几年阿里，以及腾讯，字节跳动，华为，小米等公司的面试题，把面试的要求和技术点梳理成一份大而全的“ Android架构师”面试 Xmind（实际上比预期多花了不少精力），包含知识脉络 + 分支细节。

网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。

2021年虽然路途坎坷，都在说Android要没落，但是，不要慌，做自己的计划，学自己的习，竞争无处不在，每个行业都是如此。相信自己，没有做不到的，只有想不到的。祝大家2021年万事大吉。

加入社区》https://bbs.csdn.net/forums/4304bb5a486d4c3ab8389e65ecb71ac0
f (threadPool == null) { // 当线程池 为空的时候才去创建

threadPool = new ThreadPoolExecutor(corePoolSize,

maximumPoolSize, time, TimeUnit.MILLISECONDS,

new LinkedBlockingDeque(10));

}

// 就直接执行任务

threadPool.execute®;

}

/**

• 注意在需要取消任务的时候，不要使用shutdown(),或者shutdownNow();

• 来终止当前任务，因为你终止了当前任务，那样当前线程池还是存在的，

• 再向线程池提交任务的时候，可能会因为队列已满，出现RejectedExecutionException

• 所以使用remove方法移除当前任务来达到取消任务的效果，

• 获取时线程队列使用getQueue()方法

*/

最后

都说三年是程序员的一个坎，能否晋升或者提高自己的核心竞争力，这几年就十分关键。

技术发展的这么快，从哪些方面开始学习，才能达到高级工程师水平，最后进阶到Android架构师/技术专家？我总结了这 5大块；

我搜集整理过这几年阿里，以及腾讯，字节跳动，华为，小米等公司的面试题，把面试的要求和技术点梳理成一份大而全的“ Android架构师”面试 Xmind（实际上比预期多花了不少精力），包含知识脉络 + 分支细节。

[外链图片转存中…(img-BO9AVG0O-1725761576289)]

[外链图片转存中…(img-TByZb6Rs-1725761576290)]

[外链图片转存中…(img-hdvWh1ma-1725761576290)]

网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。

2021年虽然路途坎坷，都在说Android要没落，但是，不要慌，做自己的计划，学自己的习，竞争无处不在，每个行业都是如此。相信自己，没有做不到的，只有想不到的。祝大家2021年万事大吉。

加入社区》https://bbs.csdn.net/forums/4304bb5a486d4c3ab8389e65ecb71ac0