UniversalImageLoader的一个小问题

最近在使用UniversalImageLoader时遇到了一个小问题,多个地方同时通过ImageLoader.getInstance().loadImage(url, new ImageSize(dp72, dp72)...加载图像时,有一定机率只有部分地方能正确地加载到图片,其他地方是什么结果呢?从Log看是这个样子:

1 03-19 15:41:44.167 1500-1541/xxx D/ImageLoader﹕ Start display image task [xxxxxxx/group1/M00/00/04/wKgKklUKfS-AGTJRAAAV5nnd6hE739.jpg_144x144]
2 03-19 15:41:44.167 1500-1541/xxx D/ImageLoader﹕ Load image from network [xxxxxxx/group1/M00/00/04/wKgKklUKfS-AGTJRAAAV5nnd6hE739.jpg_144x144]
3 03-19 15:41:44.167 1500-1541/xxx D/ImageLoader﹕ Cache image on disk [cxxxxxxx/group1/M00/00/04/wKgKklUKfS-AGTJRAAAV5nnd6hE739.jpg_144x144]
4 03-19 15:41:44.187 1500-1538/xxx D/ImageLoader﹕ Start display image task [xxxxxxx/group1/M00/00/04/wKgKklUKfS-AGTJRAAAV5nnd6hE739.jpg_144x144]
5 03-19 15:41:44.187 1500-1538/xxx D/ImageLoader﹕ Image already is loading. Waiting… [xxxxxxx/group1/M00/00/04/wKgKklUKfS-AGTJRAAAV5nnd6hE739.jpg_144x144]
6 03-19 15:41:44.199 1500-1541/xxx D/ImageLoader﹕ Cache image in memory [xxxxxxx/group1/M00/00/04/wKgKklUKfS-AGTJRAAAV5nnd6hE739.jpg_144x144]
7 03-19 15:41:44.199 1500-1538/xxx D/ImageLoader﹕ …Get cached bitmap from memory after waiting. [xxxxxxx/group1/M00/00/04/wKgKklUKfS-AGTJRAAAV5nnd6hE739.jpg_144x144]
8 03-19 15:41:44.219 1500-1500/xxx D/ImageLoader﹕ Display image in ImageAware (loaded from NETWORK) [xxxxxxx/group1/M00/00/04/wKgKklUKfS-AGTJRAAAV5nnd6hE739.jpg_144x144]
9 03-19 15:41:44.219 1500-1500/xxx D/ImageLoader﹕ ImageAware is reused for another image. Task is cancelled. [xxxxxxx/group1/M00/00/04/wKgKklUKfS-AGTJRAAAV5nnd6hE739.jpg_144x144]

有了Log,再结合源码,看下到底是什么原因,从上面的Log可以看到,两个地方加载同一张图片,都发现缓存中没有,所以都从网络上加载(通过分析可以知道,第1,2,3,6,8是第一个加载的地方的Log,4,5,7,9是第二个加载的地方的Log)。

UniversalImageLoader实际加载图片的类叫LoadAndDisplayImageTask,这是一个Runnable,所以我们从它的run方法开始看。首先要强调一点,由于这两个地方加载的是相同的Url,并且ImageSize相同,所以它们的memoryCacheKey是相同的,接下来就看run方法,首先是第一部分代码。

1
2
3
4
5
6
7
ReentrantLock loadFromUriLock = imageLoadingInfo.loadFromUriLock;
L.d(LOG_START_DISPLAY_IMAGE_TASK, memoryCacheKey);
if (loadFromUriLock.isLocked()) { // 注意这里
L.d(LOG_WAITING_FOR_IMAGE_LOADED, memoryCacheKey);
}
loadFromUriLock.lock();

由于memoryCacheKey相同,所以这里获得的是同一个锁,结果就是第一个线程锁住这个锁进行图片加载,所以打印出了前3行Log。

接着轮到第二个线程执行,它发现另一个线程锁住了loadFromUriLock,所以它打印出了第4和第5行Log。

然后又换第一个线程执行。

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
try {
checkTaskNotActual();
bmp = configuration.memoryCache.get(memoryCacheKey);
if (bmp == null || bmp.isRecycled()) {
bmp = tryLoadBitmap();
if (bmp == null) {
return;
}
checkTaskNotActual();
checkTaskInterrupted();
if (bmp != null && options.isCacheInMemory()) {
L.d(LOG_CACHE_IMAGE_IN_MEMORY, memoryCacheKey); // 1
configuration.memoryCache.put(memoryCacheKey, bmp);
}
} else {
loadedFrom = LoadedFrom.MEMORY_CACHE;
L.d(LOG_GET_IMAGE_FROM_MEMORY_CACHE_AFTER_WAITING, memoryCacheKey); // 2
}
checkTaskNotActual();
checkTaskInterrupted();
} catch (TaskCancelledException e) {
fireCancelEvent();
return;
} finally {
// 释放锁
loadFromUriLock.unlock();
}
// 显示图片
DisplayBitmapTask displayBitmapTask = new DisplayBitmapTask(bmp, imageLoadingInfo, engine, loadedFrom);
runTask(displayBitmapTask, syncLoading, handler, engine);

第一个线程加载完图片后,在finally中释放了锁,然后通过DisplayBitmapTask进行图片的显示,从Log中可以分析出,线程中加载完图片后打印了注释1处的Log,然后释放了锁,轮到线程2执行。

由于线程一已经加载完图片并存入了缓存了,所以线程二会进入代码注释2的代码块,打印出第7行Log。

然后线程一线程二再依次运行分别打印第8,9行Log,两个线程都取到了Bitmap,为何会一个正确加载完图片,而另一个有一定机率加载不到呢?这要看UniversalImageLoader的缓存与判断View重用的机制。

ImageLoader在加载图片前会调用ImageLoaderEngine.prepareDisplayTaskFor方法来记录一些东西,具体就是记录一个ImageAware在加载哪一个Url,以判断当图片加载完成后,这个ImageAware是否被重用来加载其他的Url了。

1
2
3
4
5
private final Map<Integer, String> cacheKeysForImageAwares = Collections.synchronizedMap(new HashMap<Integer, String>());
void prepareDisplayTaskFor(ImageAware imageAware, String memoryCacheKey) {
cacheKeysForImageAwares.put(imageAware.getId(), memoryCacheKey);
}

可以看到就是通过一个Map记录的,以ImageAware的id为键,对于LoadImage方法,使用的是NonViewAware,它的id是Url.hasCode,所以两个地方加载同一个图片,在cacheKeysForImageAwares中只有一条记录。

当加载完图片后是通过DisplayBitmapTask来显示图片并回调我们的Listener的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public void run() {
if (imageAware.isCollected()) {
L.d(LOG_TASK_CANCELLED_IMAGEAWARE_COLLECTED, memoryCacheKey);
listener.onLoadingCancelled(imageUri, imageAware.getWrappedView());
} else if (isViewWasReused()) {
L.d(LOG_TASK_CANCELLED_IMAGEAWARE_REUSED, memoryCacheKey);
listener.onLoadingCancelled(imageUri, imageAware.getWrappedView());
} else {
L.d(LOG_DISPLAY_IMAGE_IN_IMAGEAWARE, loadedFrom, memoryCacheKey);
displayer.display(bitmap, imageAware, loadedFrom);
engine.cancelDisplayTaskFor(imageAware);
listener.onLoadingComplete(imageUri, imageAware.getWrappedView(), bitmap);
}
}
1
2
3
void cancelDisplayTaskFor(ImageAware imageAware) {
cacheKeysForImageAwares.remove(imageAware.getId());
}
1
2
3
4
private boolean isViewWasReused() {
String currentCacheKey = engine.getLoadingUriForView(imageAware);
return !memoryCacheKey.equals(currentCacheKey);
}

当第一个地方执行到这个run方法时,会走到else分支里,打印出第8行的Log,然后调用ImageLoaderEngine.cancelDisplayTaskFor方法,移除在Map中的记录,并回调我们的Listener。

然后第二个地方执行到run中的isViewWasReused方法时,由于Map中的记录已经被第一个线程移除了,所以取得的currentCacheKey是null,就会判定为View被重用了,所以不能得到正确的结果。

那么为什么有时两个地方能同时得到正确的结果呢?那是因为如果当第一个线程进入到else代码块但在执行cancelDisplayTaskFor之前进行了线程调度,另一个线程还是有机会同时进入else代码块的。

其实对于NonViewAware,基本是不可能被重用的,所以感觉在这里可以做下特殊处理,或者对其生成 id的方法进行下修改(但这样会多次从网络取同一张图片)。或者像Volley一样,当执行一个请求时,如果发现这个图片正在Loading,就将其加入一个列表,当加载完后统一向这个列表里的请求发送消息,但这个修改就比较麻烦了,所以还是对NonViewAware做下特殊处理比较好,毕竟这个基本是不可能被重用的。