Imageloader<5>-ImageLoader的变量初始化

UIHandler可以在loadImage时初始化，其余的变量统一在init方法中初始化。getInstance提供让用户自定义线程池线程数量和加载策略的方法。

public class NewImageLoader {

    /** * 静态成员变量 */
    private static   NewImageLoader mImageLoader ;


    /** * 图片缓存的核心类 key为图片的路径 value为图片 */
    private LruCache<String , Bitmap>  mLruCache ;


    /** * 线程池 */
    private ExecutorService  mThreadPool ;
    private static final int DEFAULT_THREAD_COUNT  = 1;


    /** * 图片加载策略 */
    private enum  Type{
        FIFO , LIFO ;
    }

    /** * 默认的加载策略 */
    private Type mType = Type.LIFO ;


    /** * 任务队列 */
    private LinkedList<Runnable> mTaskQueue ;


    /** * 后台轮询线程 */
    private Thread mPoolThread ;

    /** * 后台轮询线程的handler ,主要用于接收后台轮询线程的消息后从线程池中取出任务进行执行 */
    private Handler mPoolThreadHandler ;


    /** * UI线程的Handler ,主要用与接收消息更新显示图片 */
    private Handler mUIHandler ;





    /** * 私有化构造函数，防止外部通过new实例化 * * 我们希望线程数和图片加载的策略可以由用户指定，我们在实例化ImageLoader传入这两个参数 */
    private NewImageLoader(int threadCount , Type type){

        // 初始化ImageLoader的变量
        init(threadCount , type);
    }


    /** * 将获取NewImageLoader实例的方法暴漏给外部，以通过类名.方法名的方式获取NewImageLoader实例 * * 通过双层判断,第一次 空值判断 可以过滤掉大部分，通过线程同步后，再一次进行空值判断 * 可以确保在实例化NewImageLoader时，当有多个线程同时到达时，只有第一个线程实例化NewImageLoader. * 当然也可以将方法设置为同步方法，只不过是这种处理方式更为高效。 */

    public static NewImageLoader getInstance(){
        if( mImageLoader == null){
            synchronized (NewImageLoader.class){
                if(mImageLoader == null){
                    // 默认一个线程 , 后进先出的加载策略
                    mImageLoader = new NewImageLoader(DEFAULT_THREAD_COUNT ,Type.LIFO);
                }
            }
        }
        return mImageLoader ;
    }

    /** * 接收用户指定线程数和加载策略的 对外提供实例的方法 通过 类名.方法名的方式调用 * @param threadCount * @param type * @return */
    public static NewImageLoader getInstance(int threadCount , Type type){
        if( mImageLoader == null){
            synchronized (NewImageLoader.class){
                if(mImageLoader == null){
                    // 默认一个线程 , 后进先出的加载策略
                    mImageLoader = new NewImageLoader(threadCount ,type);
                }
            }
        }
        return mImageLoader ;
    }


    /** * 变量初始化 mLruCache mThreadPool mType mTaskQueue mPoolThread mPoolThreadHandler * @param threadCount * @param type */
    private void init(int threadCount, Type type) {

        /** * mLruCache 初始化 */
        // 获取应用程序最大可用内存
        int maxMemory = (int) Runtime.getRuntime().maxMemory();
        int cacheMemory = maxMemory / 8 ;

        mLruCache = new LruCache<String , Bitmap>(cacheMemory){
            @Override
            protected int sizeOf(String key, Bitmap value) {
                // 计算缓存对象的大小 (每一行占据的字节数* 高度)
                return value.getRowBytes() * value.getHeight();
            }
        } ;

        /** * mThreadPool 初始化 */
        mThreadPool = Executors.newFixedThreadPool(threadCount);


        /** * type 赋值 */
        mType = type == null ? Type.LIFO : type;


        /** * mTaskQueue */
        mTaskQueue = new LinkedList<Runnable>();


        /** * mPoolThread 后台轮询线程初始化 利用android异步消息处理框架 Looper+Message+Handler实现 */
        mPoolThread = new Thread(){
            @Override
            public void run() {
                Looper.prepare();

                mPoolThreadHandler = new Handler(){
                    @Override
                    public void handleMessage(Message msg) {
                        // TODO 线程池从任务队列中去取出一个任务进行执行
                    }
                };
                Looper.loop();
            }
        };

        mPoolThread.start();
    }



}