LCD怎么判断串行还是并行

Posted 2023-04-03

如题，对于手机的LCD怎么判断它是串行的还是并行的呢？

参考技术A 串行只有2～3一般叫做SCL,SDA，并行有8 ～ 16 根，一般叫做D0~ D16本回答被提问者采纳 参考技术B 看spec
啊哈哈哈

AsyncTask 坑 多个task是串行执行还是并行的

AsyncTask作为一个优秀的封装，很多人都在用，可是我估计很多人并不清楚多个AsyncTask对象到底是串行执行的，还是并行执行的，如果是并行的，那么最多同时执行几个异步任务呢？ 源码面前无秘密，我们看一下源代码就知道了。 这里以Android-23为例。

AyncTask调用例子

       AsyncTask task = new AsyncTask() 
            @Override
            protected Object doInBackground(Object[] params) 
                return null;
            
        ;
        task.execute();

普通AsyncTask对象调用如上，主要是通过task.execute()来执行异步任务。那么execute到底做了什么呢？

AsyncTask的execute函数

看看实现：

    @MainThread
    public final AsyncTask<Params, Progress, Result> execute(Params... params) 
        return executeOnExecutor(sDefaultExecutor, params);
    

超简单，就一行。先看看executeOnExecutor函数：

   @MainThread
    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) 
        if (mStatus != Status.PENDING) 
            switch (mStatus) 
                case RUNNING:
                    throw new IllegalStateException("Cannot execute task:"
                            + " the task is already running.");
                case FINISHED:
                    throw new IllegalStateException("Cannot execute task:"
                            + " the task has already been executed "
                            + "(a task can be executed only once)");
            
        

        mStatus = Status.RUNNING;

        onPreExecute();

        mWorker.mParams = params;
        exec.execute(mFuture);

        return this;
    

主要看exec.execute(mFuture)这一行。 exec是什么呢？从execute函数里面的实现就可以看到，exec是sDefaultExecutor，那么sDefaultExecutor是什么玩意呢？ 从一下代码可以清楚的看到：

    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

    private static final int MESSAGE_POST_RESULT = 0x1;
    private static final int MESSAGE_POST_PROGRESS = 0x2;

    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

sDefaultExecutor是SerialExecutor的一个实例，而且它是个静态变量。也就是说，一个进程里面所有AsyncTask对象都共享同一个SerialExecutor对象。 那么所有的秘密就在于SerialExecutor的execute函数了。
SerialExecutor的execute函数 直接贴出SerialExecutor的实现：

    private static class SerialExecutor implements Executor 
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        Runnable mActive;

        public synchronized void execute(final Runnable r) 
            mTasks.offer(new Runnable() 
                public void run() 
                    try 
                        r.run();
                     finally 
                        scheduleNext();
                    
                
            );
            if (mActive == null) 
                scheduleNext();
            
        

        protected synchronized void scheduleNext() 
            if ((mActive = mTasks.poll()) != null) 
                THREAD_POOL_EXECUTOR.execute(mActive);
            
        
    

代码本身很简单，从execute里面就能看出，异步任务r被放到了ArrayDeque对象mTasks中，然后通过scheduleNext()来从mTasks里面得到一个任务去一个后台线程执行。 在一个异步任务执行后，再次调用scheduleNext来执行下一个任务（run函数）。 所以，很清楚，其实SerialExecutor是一个一个执行任务的，而所有的AsyncTask对象又共享同一个SerialExecutor对象（静态成员）。 所以，我们可以肯定：

至少在Android-23 SDK里面，多个AsyncTask对象是串行执行的。

实际是不是呢，做个实验就知道：
测试代码超简单，就是创建3个AsyncTask对象，做了一样的事情，就是在doInBackground里面打印log。 我们从log可以清楚的看到，AsyncTask对象1，2，3是串行执行的。 这也证实了，Android-23 sdk里面 多个AsyncTask对象确实是串行执行的。

如何并行执行多个AsyncTask对象

那么有没有办法并行执行呢？肯定有了。 看AsyncTask的实现，里面有个Executor

   public static final Executor THREAD_POOL_EXECUTOR
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

如果我们直接使用THREAD_POOL_EXECUTOR会怎么样呢？ 看下图：
这次的执行顺序跟上次不一样了。可以看出好像3个任务并行执行了。不像之前的排队执行。 关于THREAD_POOL_EXECUTOR，有兴趣可以看进去，大致的意思就是，

    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;

这是个线程池，有两个概念，一个是线程池里面核心线程数，一个是最大线程数。从上面的定义可以大概看出来，核心线程数是CPU个数+1，最大是CPU个数 * 2 + 1. 至于怎么调度执行，那就有一套算法了，这里就不介绍了。但是有一点可以肯定，它不是排队在一个线程里面执行的，所以也就看到了上面的结果。
实际上，我们也可以自己实现 一个执行器，如：

public class MyThreadPoolExecutor extends AbstractExecutorService

然后调用AsyncTask的executeOnExecutor，把自己的MyThreadPoolExecutor对象传进去，达到自己想要的效果。 不过，还是推荐使用系统默认的，也就是排队执行的方式，除非有特殊需求，我们才搞特殊化处理。