我们先了解什么是异步
开发经常会遇到比较耗时任务，比如网络连接，数据库操作等情况时，如果这些操作都是放在主线程（UI线程）中，则会造成UI的卡死，Android中可以使用Thread和Handler两种异步方式来解决这种问题。
同步和异步的区别：
网络答案：
1、同步执行的话，就是程序会呆板地从头执行到尾，耗时间的东西不执行完，程序不会继续往下走，等待时间长的话，有时候就会造成失去响应了。
2、异步的好处，就是把一些东西，特别是耗时间的东西扔到后台去运行了(doInBackground)，程序可以继续做自己的事情，防止程序卡在那里失去响应。
答案二：
1、同步是指两个线程的运行是相关的，其中一个线程要阻塞等待另外一个线程的运行。
2、异步的意思是两个线程毫无相关，自己运行自己的。
答案三：
1、同步是指：发送方发出数据后，等接收方发回响应以后才发下一个数据包的通讯方式。
2、异步是指：发送方发出数据后，不等接收方发回响应，接着发送下个数据包的通讯方式。
答案四：
1、同步：提交请求->等待服务器处理->处理完毕返回 这个期间客户端浏览器不能干任何事
2、异步: 请求通过事件触发->服务器处理（这是浏览器仍然可以作其他事情）->处理完毕
答案五：
1、同步就是你叫我去吃饭，我听到了就和你去吃饭；如果没有听到，你就不停的叫，直到我告诉你听到了，才一起去吃饭。
2、异步就是你叫我，然后自己去吃饭，我得到消息后可能立即走，也可能等到下班才去吃饭。
AsyncTask
处理耗时操作需要分别在Thread和Handler中编写代码逻辑，很繁琐，所以Google官方帮我们在Thread和Handler的基础上封装出了AsyncTask。
AsyncTask的使用中会遇到三种泛型参数：Params, Progress 和 Result
Params
表示用于AsyncTask执行任务的参数的类型
Progress
表示在后台线程处理的过程中，可以阶段性地发布结果的数据类型
Result
表示任务全部完成后所返回的数据类型
执行任务
调用AsyncTask的execute()方法传入参数并执行任务 AsyncTask会依次调用四个方法 分别是：
onPreExecute
doInBackground
onProgressUpdate
onPostExecute
onPreExecute
onPreExecute()方法的MainThread注解，表示该方法是运行在主线程中的 通常通常用于显示进度条
doInBackground
将在onPreExecute 方法执行后马上执行，该方法运行在后台线程中。这里将主要负责执行那些很耗时的任务。还可以调用publishProgress来更新实时的任务进度。
onProgressUpdate
在publishProgress方法被调用后，UI 线程将调用这个方法返回进展情况，可以通过一个进度条进行展示。
onPostExecute
在doInBackground 执行完成后，该方法将被UI 线程调用
onCancelled
用户取消线程操作的时候调用。
在主线程中调用onCancelled()的时候调用。
到这里AsyncTask类基本都懂了吧 接下来就还要了解Executor
Executor
我们知道线程池就是线程的集合，线程池集中管理线程，以实现线程的重用，降低资源消耗，提高响应速度等。线程用于执行异步任务，单个的线程既是工作单元也是执行机制，从JDK1.5开始，为了把工作单元与执行机制分离开，Executor框架诞生了，他是一个用于统一创建与运行的接口。Executor框架实现的就是线程池的功能。
Executor接口的实现类ThreadPoolExecutor类或者ScheduledThreadPoolExecutor类的对象，然后调用其execute（）方法或者submit（）方法把工作任务添加到线程中，如果有返回值则返回Future对象。其中Callable对象有返回值，因此使用submit（）方法；而Runnable可以使用execute（）方法，此外还可以使用submit（）方法，只要使用callable（Runnable task）或者callable(Runnable task, Object result)方法把Runnable对象包装起来就可以，使用callable（Runnable task）方法返回的null，使用callable(Runnable task, Object result)方法返回result。 出处——tongdanping
开始封装AsyncTask
定义一个异步任务执行器
完整代码
public class AsyncTaskExecutor {
/**
* 参考 {@link android.os.AsyncTask}
*/
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
// 希望核心池中至少有2个线程，最多4个线程，
// CPU计数少1，以避免饱和
// 具有后台工作的CPU
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;
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
@Override
public Thread newThread(Runnable r) {
return new Thread(r, "AsyncTaskExecutor #" + mCount.getAndIncrement());
}
};
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<>(128);
/**
*
* An {@link java.util.concurrent.Executor} 可用于并行执行任务的。
*/
private static final ThreadPoolExecutor 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;
}
public static void execute(Runnable runnable) {
THREAD_POOL_EXECUTOR.execute(runnable);
}
public static Future<?> submit(Runnable runnable) {
return THREAD_POOL_EXECUTOR.submit(runnable);
}
public static <T> Future<T> submit(Runnable runnable, T result) {
return THREAD_POOL_EXECUTOR.submit(runnable, result);
}
public static <T> Future<T> submit(Callable<T> callable) {
return THREAD_POOL_EXECUTOR.submit(callable);
}
public static ThreadPoolExecutor executor(){
return THREAD_POOL_EXECUTOR;
}
}
有时候，系统需要处理非常多的执行时间很短的请求，这样每一个请求都开启一个新线程，系统就要不断的进行线程的创建和销毁，创建和销毁线程所花时间会可能会比线程执行的时间还长。而且当线程数量太多时，将该cpu带来额外的消耗，可能会非常巨大。所以就有了线程池 线程池解决的核心问题就是资源管理问题
在定义线程池
DefaultWorkExecutor
public class DefaultWorkExecutor extends ThreadPoolExecutor {
private static final int CPU_SIZE = Runtime.getRuntime().availableProcessors();
private static final int CORE_SIZE;
private static final int MAX_SIZE;
private static final long KEEP_ALIVE_TIME = 1L;
public DefaultWorkExecutor() {
this(CORE_SIZE, MAX_SIZE, KEEP_ALIVE_TIME, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
}
static {
// 线程池核心线程数为 cpu 核心数加一
CORE_SIZE = CPU_SIZE + 1;
// 线程池最大线程数为 cpu 核心数2被加一
MAX_SIZE = CPU_SIZE * 2 + 1;
}
private DefaultWorkExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
}
最后用单例执行器调用
public class MineExecutors {
private static volatile MineExecutors sInstance = null;
private Handler mHandler;
private ThreadPoolExecutor mIoExecutor;
private ThreadPoolExecutor mAsyncExecutor;
private MineExecutors() {
mHandler = new Handler(Looper.getMainLooper());
mIoExecutor = new DefaultWorkExecutor();
mAsyncExecutor = AsyncTaskExecutor.executor();
}
private static MineExecutors instance() {
if (sInstance == null) {
synchronized (MineExecutors.class) {
if (sInstance == null) {
sInstance = new MineExecutors();
}
}
}
return sInstance;
}
public static ThreadPoolExecutor ioExecutor() {
return instance().mIoExecutor;
}
public static ThreadPoolExecutor asyncExecutor() {
return instance().mAsyncExecutor;
}
public static void executeOnUiThread(Runnable runnable) {
instance().mHandler.post(runnable);
}
}
使用方法
MineExecutors.asyncExecutor().execute (() -> {
/**
* 耗时任务
*/
//返会主线程
MineExecutors.executeOnUiThread(() -> {
/**
* 刷新UI
*/
});
});
最后
您的点赞收藏就是对我最大的鼓励！ 欢迎关注我，分享Android干货，交流Android技术。 对文章有何见解，或者有何技术问题，欢迎在评论区一起留言讨论！最后给大家分享一些Android相关的视频教程，感兴趣的朋友可以去看看。
【Android源码解析】Android中高级架构进阶学习——百大框架源码解析Retrofit/OkHttp/Glide/RxJava/EventBus...._哔哩哔哩_bilibili
Android流行框架零基础入门到精通全套教程/热修复/Glide/插件化/Retrofit/OKHTTP/Gson/组件化/Jetpack/IOC/高德地图_哔哩哔哩_bilibili
价值100W+Android实战项目大全/高级UI/灵动的锦鲤/QQ空间热修复/插件化框架/组件化框架设计/网络访问框架/RXJava/IOC/MVVM/NDK_哔哩哔哩_bilibili
本文转自 https://juejin.cn/post/7035272631637049381，如有侵权，请联系删除。
