ITPub博客

首页 > 应用开发 > IT综合 > 实现直播app源代码开发,使用异步提高系统性能

实现直播app源代码开发,使用异步提高系统性能

IT综合 作者:云豹科技晓彤 时间:2021-11-29 16:57:30 0 删除 编辑

直播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, ProgressResult

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源代码使用异步,来提升系统效率的实现。
声明:本文由云豹科技转发自九狼博客,如有侵权请联系作者删除


来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/70002045/viewspace-2844690/,如需转载,请注明出处,否则将追究法律责任。

请登录后发表评论 登录
全部评论
音视频软件开发相关知识科普账号

注册时间:2021-06-11

  • 博文量
    163
  • 访问量
    36503