Android进阶之图片加载框架搭建(一)消息机制原理分析及在并发中的应用

引言

目前市面上的图片加载框架不要太多:universal-imageloader、Glide、Piccosa、Freso...简直群魔乱舞。但是作为一名有追求的coder,必须懂其中的实现原理,并敢于制造轮子。由于这个专题涉及的内容比较多,暂定分两篇博客讲完它。一个完整的图片加载框架主要包括三大块:
1.图片下载任务调度.
2.图片的缩放.
3.图片的两级缓存处理.
其中图片加载任务的调度是框架的核心,这里结合Android的Handler机制单独讲解,在本篇的结尾会模拟图片的加载场景,初步搭建图片加载并发框架,第二篇博客会给出完全的实现代码。

Android消息机制分析

提到消息机制读者应该都不陌生:由于子线程不能直接做UI操作,Handler用于耗时子线程工作完毕,发送消息给UI线程,更新UI。这的确没错,但是更新UI只是Handler的一个特殊的使用场景。我的理解是,它背后的本质是一种生产者-消费者模型。消息机制结合java线程并发机制,可以实现并发任务管理。所以本节着重理解一下Handler机制背后的实现原理,然后据此构建并发任务管理模型。整个消息模型结构如下:MessageQueue是仓库,Handler是生产者,消费者(主要是UI线程,也可以是绑定Lopper的线程,如HandlerThread,这个后面会讲到)通过Looper不断的从消息队列中取出消息并将其交给各自的目标Handler消费掉。


Android进阶之图片加载框架搭建(一)消息机制原理分析及在并发中的应用_第1张图片

Looper源码分析

Looper为线程维护一个消息循环,先看看它的构造方法:

private Looper(boolean quitAllowed) {    
    mQueue = new MessageQueue(quitAllowed);    
    mThread = Thread.currentThread();
}

可以看到构造方法为私有,初始化了消息队列,绑定当前线程,构造方法在prepare()方法中被调用:

/** Initialize the current thread as a looper.  
* This gives you a chance to create handlers that then reference  
* this looper, before actually starting the loop. Be sure to call  
* {@link #loop()} after calling this method, and end it by calling 
 * {@link #quit()}. 
 */
public static void prepare() {    
      prepare(true);
}

private static void prepare(boolean quitAllowed) {    
    if (sThreadLocal.get() != null) {        
        throw new RuntimeException("Only one Looper may be created per thread");   
     }    
    sThreadLocal.set(new Looper(quitAllowed));
}

根据源码及注释,prepare为当前线程创建一个Looper;在开启消息循环之前必须调用该方法;且Looper实例存放在TheadLocal当中;一个线程只能绑定一份Looper,否则会抛出异常。
再看看loop()方法

/** * Run the message queue in this thread. Be sure to call 
* {@link #quit()} to end the loop. 
*/
public static void loop() {    
    final Looper me = myLooper();    
    if (me == null) {        
        throw new RuntimeException("No Looper; 
        Looper.prepare() wasn't called on this thread.");    
     }   
     final MessageQueue queue = me.mQueue;   

     // Make sure the identity of this thread is that of the local process,    
    // and keep track of what that identity token actually is.                  Binder.clearCallingIdentity();    
    final long ident = Binder.clearCallingIdentity();    
    for (;;) {        
        Message msg = queue.next(); // might block       
        if (msg == null) {            
          // No message indicates that the message queue is quitting. 
          return;        
        }        
        // This must be in a local variable, in case a UI event sets the logger        
        final Printer logging = me.mLogging;        
        if (logging != null) {            
            logging.println(">>>>> Dispatching to " + msg.target + " " +                    msg.callback + ": " + msg.what);        
        }        
      final long traceTag = me.mTraceTag;        
      if (traceTag != 0) {            T
          race.traceBegin(traceTag, msg.target.getTraceName(msg));           
      }       
      try {            
          msg.target.dispatchMessage(msg);        
      } finally {           
          if (traceTag != 0) {                
              Trace.traceEnd(traceTag);            
          }        
      }        
      if (logging != null) {            
          logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);        
      }        
      // Make sure that during the course of dispatching the        
      // identity of the thread wasn't corrupted.        
      final long newIdent = Binder.clearCallingIdentity();        
      if (ident != newIdent) {            
          Log.wtf(TAG, "Thread identity changed from 0x"                    
          + Long.toHexString(ident) + " to 0x"                    
          + Long.toHexString(newIdent) + " while dispatching to "                    + msg.target.getClass().getName() + " "                    
          + msg.callback + " what=" + msg.what);       
     }        msg.recycleUnchecked();   
  }
}

循环体中:
1>从消息队列中取消息msg
2>msg的target(即Handler)分发处理消息

Loop的主要作用:
1>与当前线程绑定,保证一个线程只会有一个Looper实例,同时一个Looper实例也只有一个MessageQueue。
2>loop()方法,不断从MessageQueue中去取消息,交给消息的target属性的dispatchMessage去处理。现在异步消息处理线程已经有了消息队列(MessageQueue),也有了在无限循环体中取出消息的哥们,那么我们看看生产者Handler吧。

Handler源码分析

依然是先从构造方法看起:

 public Handler() {    
    this(null, false);
}

public Handler(Callback callback, boolean async) {    
    if (FIND_POTENTIAL_LEAKS) {        
        final Class klass = getClass();        
        if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&                
            (klass.getModifiers() & Modifier.STATIC) == 0) {  
              ...        
        }   
     }    
    mLooper = Looper.myLooper();    
    if (mLooper == null) {       
         throw new RuntimeException( "Can't create handler inside thread that has not called Looper.prepare()");   
    }    
    mQueue = mLooper.mQueue;    
    mCallback = callback;    
    mAsynchronous = async;
}

1> 通过Looper.myLooper()获取了当前线程保存的Looper实例
2>通过Looper实例得到消息队列,于是Handler和Looper、消息队列
3>Handler的创建前提:所在的线程必须已经绑定Looper(这个很重要,它是handler实现线程的切换的关键)建立关联
然后我们在看看消息的产生:

public final boolean sendMessage(Message msg){    
      return sendMessageDelayed(msg, 0);
}

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {    
    MessageQueue queue = mQueue;   
    if (queue == null) {        
        RuntimeException e = new RuntimeException( this + "sendMessageAtTime() called with no mQueue");   
        Log.w("Looper", e.getMessage(), e);        
        return false;    
    }    
    return enqueueMessage(queue, msg, uptimeMillis);
}

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {    
    msg.target = this;    
    if (mAsynchronous) {        
        msg.setAsynchronous(true);   
     }    
    return queue.enqueueMessage(msg, uptimeMillis);
}

最终调用到enqueueMessage()方法,这里将消息的目标设为自己,然后调用消息队列的enqueueMessage()方法[记得前面loop()方法的msg.target.dispatchMessage(msg)吧]。
于是一个消息的流向如下:Handler生成的消息进入到消息队列中,Looper将其从消息队列中取出,然后分配给产生它的Handler对象,由dispatchMessage将它处理掉。下面看看最后消息是如何被消费掉的:

public void dispatchMessage(Message msg) {    
    if (msg.callback != null) {        
        handleCallback(msg);    
    } else {        
        if (mCallback != null) {            
            if (mCallback.handleMessage(msg)) {                
                return;            
            }        
    }        
    handleMessage(msg);    
    }
}

最后终于走到我们熟悉一万遍的handleMessage方法。
大致读完了主要源码,我们就明白Handler是如何实现线程切换的:
1>前提:Handler的创建必须依赖已经绑定Looper线程
2>sendMessage方法只是对消息队列做了入队操作,可以在其他线程中调用
3>Looper的loop()方法会最终调用handlerMessage()方法,这个方法就运行在handler所依附的线程。
那么细心的读者会有这样的疑惑:既然主线程的Looper进入死循环了,那如何处理其他事务呢?还是看看主线程ActivityThread的初始化代码吧:

public static void main(String[] args) {
    ...
    //创建Looper和MessageQueue对象,用于处理主线程的消息
    Looper.prepareMainLooper();
    //创建ActivityThread对象
    ActivityThread thread = new ActivityThread();
    //建立Binder通道 (创建新线程)
    thread.attach(false);
    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }
    if (false) {
        Looper.myLooper().setMessageLogging(new
                LogPrinter(Log.DEBUG, "ActivityThread"));
    }
    // End of event ActivityThreadMain.
    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
    //消息循环运行
    Looper.loop();
    ...
}

我们看到main方法里在开启循环之前,调用了thread.attach(false),这里便会创建一个Binder线程(具体是指ApplicationThread,Binder的服务端,用于接收系统服务AMS发送来的事件),该Binder线程通过Handler将Message发送给主线程。

图片加载框架的任务调度模型

明白了android消息机制原理,我们可以利用它方便的构建并发任务管理模型:开启一个后台线程绑定Looper进行轮询(这里我们采用HandlerThread),不停从任务队列里查询任务,如果有,则取出交给线程池执行,另外可以通过计数信号量Semaphore来控制并发数。代码如下:

package com.qicode.backloopthreaddemo;
import android.content.Context;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import java.util.LinkedList;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Semaphore;
/** * Created by chenming on 16/12/2. 
* 模拟后台下载图片的任务并发管理代码 
*/
public class ImageLoader {    
    private static ImageLoader mInstance;    
    /**     
     * 线程池    
     */        
    private ExecutorService mThreadPool;    
    /**     
     * 后台轮询线程及Handler,信号量   
     */ 
    private HandlerThread mBackLoopThread;//后台线程    
    private BackLoopHandler mBackLoopThreadHandler;//发消息给后台Looper,调度下载线程    
    private Semaphore  mBackLoopThreadSemaphore;//后台下载任务个数限制的信号量,控制同时下载的数量    
    private LinkedList mTaskQueue;//所有任务队列   
    private Type mType = Type.LIFO;//调度方式,默认后进先出   
    private class BackLoopHandler extends Handler {
        BackLoopHandler(Looper looper) {            
            super(looper);        
        }        
        @Override        
        public void handleMessage(Message msg) {            
            //同时间的下载任务个数信号量同步,执行任务到达上限,则阻塞            
            try {                
                mBackLoopThreadSemaphore.acquire();            
            } catch (InterruptedException e) { 
               e.printStackTrace();            
            }                 
            mThreadPool.execute(getTask());        
        }   
     }    

    public static ImageLoader getInstance(Context context) {       
        if (mInstance == null) {            
            synchronized (ImageLoader.class) {                
                if (mInstance == null) {                    
                    mInstance = new ImageLoader(context, 3, Type.LIFO);               
                 }            
            }       
         }        
         return mInstance;    
    }    

    /**     
     * @param threadCount 同时下载图片线程个数     
     * @param type        调度策略     
     */    
    private ImageLoader(Context context, int threadCount, Type type) {        
        init(context, threadCount, type);    
    }    

    private void init(Context context, int threadCount, Type type) {
        initTaskDispatchThread();        
        mBackLoopThreadSemaphore = new Semaphore(threadCount);//并发数量控制信号量        
        // 创建线程池        
        mThreadPool = Executors.newFixedThreadPool(threadCount);          
        mTaskQueue = new LinkedList();        
        mType = type;    
    }    
    /**     
     * 初始化后台调度线程,结合信号量及调度策略,实现并发下载     
     */    
    private void initTaskDispatchThread() {        
        //后台轮询线程初始化HandlerThread        
        mBackLoopThread = new HandlerThread("backthread");
        mBackLoopThread.start();        
        mBackLoopThreadHandler = new BackLoopHandler(mBackLoopThread.getLooper());    
    }    
    /**     
     * 根据调度策略取任务     
     *     
     * @return     
     */    
    private Runnable getTask() {        
        if (mType == Type.FIFO) {            
            return mTaskQueue.removeFirst();        
        }        
        return mTaskQueue.removeLast();    
    }    

    private int runnableIndex;    
    private class TestRunnable implements Runnable{        
        private int mIndex;        
        public TestRunnable(int index){            
            mIndex = index;        
        }        

        @Override        
        public void run() {            
            try {                
                Thread.sleep(5000);            
            } catch (InterruptedException e) { 
               e.printStackTrace();            
            }            
            Log.e("TAG", "LoadImage:" + mIndex + "下载完成");
            mBackLoopThreadSemaphore.release();//执行完,释放信号量        
          }    
    }    

    /**     
     *模拟下载图片耗时线程     
     */    
     public void testLoadImage(){        
        runnableIndex ++;        
        Runnable runnable = new TestRunnable(runnableIndex);
        addTask(runnable);    
    }    

    /**     
     * 新建任务,添加到后台任务队列     
     *     
     * @param runnable     
     */    
    public synchronized void addTask(Runnable runnable) {
        mTaskQueue.add(runnable);
        mBackLoopThreadHandler.sendEmptyMessage(0x110);//给后台调度Looper发消息,    
    }    
    /**     
     * 任务调度类型     
     */    
    public enum Type {        
        FIFO, LIFO;    
    }
}

工作流程如下:
1.初始化工作:绑定mBackLoopThread和mBackLoopThreadHandler,开启消息循环;
2 addTask()方法将任务加入队列,并通过mBackLoopThreadHandler向后台线程发送消息,后台轮询线程从队列里取任务;
3.并发数未满上限(这里设的3),线程池执行任务;否则阻塞
4.单个任务执行完成,释放计数信号量。测试代码:

findViewById(R.id.btn).setOnClickListener(new View.OnClickListener() {    
    @Override    
    public void onClick(View view) {
        mImageLoader.testLoadImage();    
    }
});

测试时快速连续按按钮6次,得出的Log如下:

12-02 11:57:07.810 17956-18071/com.qicode.backloopthreaddemo E/TAG: LoadImage:1下载完成
12-02 11:57:07.980 17956-18077/com.qicode.backloopthreaddemo E/TAG: LoadImage:2下载完成
12-02 11:57:08.130 17956-18082/com.qicode.backloopthreaddemo E/TAG: LoadImage:3下载完成
12-02 11:57:12.815 17956-18071/com.qicode.backloopthreaddemo E/TAG: LoadImage:6下载完成
12-02 11:57:12.980 17956-18077/com.qicode.backloopthreaddemo E/TAG: LoadImage:5下载完成
12-02 11:57:13.135 17956-18082/com.qicode.backloopthreaddemo E/TAG: LoadImage:4下载完成

希望通过本篇博客,读者能布局理解Android消息机制的原理,并加以灵活应用,这里提供了它在图片加载框架里的应用,下一篇博客将在此基础上,讨论一下整个图片加载框架的实现。

你可能感兴趣的:(Android进阶之图片加载框架搭建(一)消息机制原理分析及在并发中的应用)