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

public class NewImageLoader {

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


    /**
     * 图片缓存的核心类   key为图片的路径 value为图片
     */
    private LruCache  mLruCache ;


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


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

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


    /**
     * 任务队列
     */
    private LinkedList 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(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();


        /**
         * 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();
    }



}