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



}
  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
  
39
  
40
  
41
  
42
  
43
  
44
  
45
  
46
  
47
  
48
  
49
  
50
  
51
  
52
  
53
  
54
  
55
  
56
  
57
  
58
  
59
  
60
  
61
  
62
  
63
  
64
  
65
  
66
  
67
  
68
  
69
  
70
  
71
  
72
  
73
  
74
  
75
  
76
  
77
  
78
  
79
  
80
  
81
  
82
  
83
  
84
  
85
  
86
  
87
  
88
  
89
  
90
  
91
  
92
  
93
  
94
  
95
  
96
  
97
  
98
  
99
  
100
  
101
  
102
  
103
  
104
  
105
  
106
  
107
  
108
  
109
  
110
  
111
  
112
  
113
  
114
  
115
  
116
  
117
  
118
  
119
  
120
  
121
  
122
  
123
  
124
  
125
  
126
  
127
  
128
  
129
  
130
  
131
  
132
  
133
  
134
  
135
  
136
  
137
  
138
  
139
  
140
  
141
  
142
  
143
  
144
  
145
  
146
  
147
  
148
  
149
  
150
  
151
  
152
  
153
  
154
  
155
  
156
  
157
  
158
  
159
  
160
  
161
  
162
  
163
  
164
  
165
  
166
  
167
  
168
  
169
  
170
  
171
  
172
  
173
  
174
  
175
  
176
 

文章来源: artisan.blog.csdn.net，作者：小小工匠，版权归原作者所有，如需转载，请联系作者。

原文链接：artisan.blog.csdn.net/article/details/50224511