直播app源代码开发经常会遇到比较耗时任务,比如网络连接,数据库操作等情况时,如果这些操作都是放在主线程(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 方法执行后马上执行,该方法运行在直播app源代码后台线程中。这里将主要负责执行那些很耗时的任务。还可以调用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;
}
}
有时候,直播app源代码需要处理非常多的执行时间很短的请求,这样每一个请求都开启一个新线程,系统就要不断的进行线程的创建和销毁,创建和销毁线程所花时间会可能会比线程执行的时间还长。而且当线程数量太多时,将该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
*/
});
});
以上就是直播app源代码使用异步,来提升系统效率的实现。
声明:本文由云豹科技转发自九狼博客,如有侵权请联系作者删除