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

ITPub博客

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