Android进阶必学系列：Bitmap的高效加载和Cache(1)，360°深入了解Flutter

}

V mapValue;
//get是线程安全的操作
synchronized (this) {
//LinkedHashMap的get方法中调afterNodeAccess，会移到链表尾部
mapValue = map.get(key);
if (mapValue != null) {
hitCount++;
return mapValue;
}
missCount++;
}
…
}

/**

• 缓存key-value，value会存在 队尾
• @return 之前也是这个key存的value
  */
  public final V put(K key, V value) {
  if (key == null || value == null) {
  //不允许 null key、null value
  throw new NullPointerException(“key == null || value == null”);
  }

V previous;
//可见put操作是线程安全的
synchronized (this) {
putCount++;
size += safeSizeOf(key, value);
//强引用存入map（不会被动地被系统回收），其因为是LinkedHashMap，会放在队尾
previous = map.put(key, value);
if (previous != null) {
//如果前面已这个key，那么替换后调整下当前缓存大小
size -= safeSizeOf(key, previous);
}
}

if (previous != null) {
entryRemoved(false, key, previous, value);
}
//重新调整大小
trimToSize(maxSize);
return previous;
}

/**

• 比较 当前已缓存的大小 和最大容量，决定 是否删除
  */
  private void trimToSize(int maxSize) {
  while (true) {
  K key;
  V value;
  synchronized (this) {
  if (size < 0 || (map.isEmpty() && size != 0)) {
  throw new IllegalStateException(getClass().getName()

• “.sizeOf() is reporting inconsistent results!”);
  }

if (size <= maxSize) {
//大小还没超过最大值
break;
}

//已经达到最大容量

//因为是访问顺序，所以遍历的最后一个就是最近没有访问的，那么就可以删掉它了！
Map.Entry<K, V> toEvict = null;
for (Map.Entry<K, V> entry : map.entrySet()) {
toEvict = entry;
}
// END LAYOUTLIB CHANGE

if (toEvict == null) {
break;
}

key = toEvict.getKey();
value = toEvict.getValue();
map.remove(key);
size -= safeSizeOf(key, value);
evictionCount++;
}
//因为是为了腾出空间，所以这个回调第一个参数是true
entryRemoved(true, key, value, null);
}
}

protected void entryRemoved(boolean evicted, K key, V oldValue, V newValue) {}

…
}

由以上代码及注释，可见LruCache的算法实现是依靠 设置了访问顺序的LinkedHashMap。因为是访问顺序模式，get、put操作都会调整k-v到链表尾部。在缓存将满时，遍历LinkedHashMap，因为是访问顺序模式，所以遍历的最后一个就是最近没有使用的，然后删除即可。

2.2 DiskLruCache

DiskLruCache是实现磁盘缓存，所以需要设备存储的读写权限；一般是从网络请求图片后缓存到磁盘中，所以还需要网络权限。

复制代码

DiskLruCache，不是官方提供，所以需要引入依赖：

implementation ‘com.jakewharton:disklrucache:2.0.2’
复制代码

• DiskLruCache的创建，不是通过new，而是open方法，需要传入缓存目录、最大缓存容量。
• 缓存的添加，是通过Editor，缓存对象的编辑器。传入图片url的key 调用DiskLruCache的edit方法获取Editor（如果缓存正在被编辑就会返回null），可以从Editor得到文件输出流，这样就可以写入到文件系统了。
• 缓存的获取，传入图片url的key 调用DiskLruCache的get方法 得到SnapShot，可从SnapShoty获取文件输入流，这样就用BitmapFactory得到bitmap了。
• 缓存的删除，DiskLruCache的remove方法可以删除key对应的缓存。

通过查看源码，发现LinkedHashMap内部也是维护了访问顺序的LinkedHashMap，原理上和LruCache是一致的。只是使用上有点点复杂，毕竟涉及文件的读写。

具体使用及注意点如下代码：

private void testDiskLruCache(String urlString) {
long maxSize = 5010241024;

try {
//一、创建DiskLruCache
//第一个参数是要存放的目录，这里选择外部缓存目录（若app卸载此目录也会删除）；
//第二个是版本一般设1；第三个是缓存节点的value数量一般也是1；
//第四个是最大缓存容量这里取50M
mDiskLruCache = DiskLruCache.open(getExternalCacheDir(), 1, 1, maxSize);

//二、缓存的添加：1、通过Editor，把图片的url转成key，通过edit方法得到editor,然后获取输出流，就可以写到文件系统了。
DiskLruCache.Editor editor = mDiskLruCache.edit(hashKeyFormUrl(urlString));
if (editor != null) {
//参数index取0（因为上面的valueCount取的1）
OutputStream outputStream = editor.newOutputStream(0);
boolean downSuccess = downloadPictureToStream(urlString, outputStream);
if (downSuccess) {
//2、编辑提交，释放编辑器
editor.commit();
}else {
editor.abort();
}
//3、写到文件系统，会检查当前缓存大小，然后写到文件
mDiskLruCache.flush();
}
} catch (IOException e) {
e.printStackTrace();
}

//三、缓存的获取
try {
String key = hashKeyFormUrl(urlString);
DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);
FileInputStream inputStream = (FileInputStream)snapshot.getInputStream(0);
// Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
// mIvBitamp.setImageBitmap(bitmap);

//注意，一般需要采样加载，但文件输入流是有序的文件流，采样时两次decodeStream影响文件流的文职属性，导致第二次decode是获取是null
//为解决此问题，可用文件描述符
FileDescriptor fd = inputStream.getFD();

//采样加载（就是前面讲的bitmap的高效加载）
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds=true;
BitmapFactory.decodeFileDescriptor(fd,null,options);
ViewGroup.LayoutParams layoutParams = mIvBitamp.getLayoutParams();
options.inSampleSize = getInSampleSize(layoutParams.width, layoutParams.height, options.outWidth, options.outHeight);
options.inJustDecodeBounds = false;
Bitmap bitmap = BitmapFactory.decodeFileDescriptor(fd, null, options);

//存入内容缓存，绘制到view。（下次先从内存缓存获取，没有就从磁盘缓存获取，在没有就请求网络–“三级缓存”）
mBitmapLruCache.put(key,bitmap);

runOnUiThread(new Runnable() {
@Override
public void run() {
mIvBitamp.setImageBitmap(mBitmapLruCache.get(key));
}
});

} catch (IOException e) {
e.printStackTrace();
}
}

/**

• 下载图片到文件输入流
  */
  private boolean downloadPictureToStream(String urlString, OutputStream outputStream) {
  URL url = null;
  HttpURLConnection urlConnection = null;
  BufferedInputStream in = null;
  BufferedOutputStream out = null;
  try {
  url = new URL(urlString);
  urlConnection = (HttpURLConnection) url.openConnection();
  in = new BufferedInputStream(urlConnection.getInputStream());
  out = new BufferedOutputStream(outputStream);

int b;
while ((b=in.read()) != -1) {
//写入文件输入流
out.write(b);
}
return true;
} catch (IOException e) {
e.printStackTrace();
}finally {
if (urlConnection != null) {
urlConnection.disconnect();
}
try {
if (in != null) {in.close();}
if (out != null) {out.close();}
} catch (IOException e) {
e.printStackTrace();
}
}
return false;
}

/**

• 图片的url转成key，使用MD5
  */
  private String hashKeyFormUrl(String url) {
  try {
  MessageDigest digest = MessageDigest.getInstance(“MD5”);
  return byteToHexString(digest.digest(url.getBytes()));
  } catch (NoSuchAlgorithmException e) {
  e.printStackTrace();
  }
  return null;
  }

private String byteToHexString(byte[] bytes) {
StringBuffer stringBuffer = new StringBuffer();
for (int i = 0; i < bytes.length; i++) {
String hex = Integer.toHexString(0XFF & bytes[i]);
if (hex.length()==1) {
stringBuffer.append(0);
}
stringBuffer.append(hex);
}
return stringBuffer.toString();
}

三、ImageLoader

前面说的 Bitmap的高效加载、LruCache、DiskLruCache，是一个图片加载框架必备的功能点。下面就来封装一个ImageLoader。首先罗列 实现的要点：

• 图片压缩，就是采样加载
• 内存缓存，LruCache
• 磁盘缓存，DiskLruCache
• 网络获取，请求网络url
• 同步加载，外部子线程同步执行
• 异步加载，ImageLoader内部线程异步执行

说明，

1. ”三级缓存“的逻辑：加载时 先从内存缓存获取，有就返回bitmap绘制图片到view，若没有就从磁盘缓存获取；磁盘缓存有就返回bitmap并缓存到内存缓存，没有就请求网络；网络请求回来，就缓存到磁盘缓存，然后从磁盘缓存获取返回。
2. 同步加载，是在外部的子线程中执行，同步加载方法内部没有开线程，所以加载过程是耗时的 会阻塞 外部的子线程，加载完成后 需要自行切到主线程绘制到view。
3. 异步加载，外部可在任意线程执行，因为内部实现是在子线程(线程池)加载，并且内部会通过Handler切到主线程，只需要传入view，内部就可直接绘制Bitmap到view。

详细如下

public class ImageLoader {

private static final String TAG = “ImageLoader”;

private static final long KEEP_ALIVE_TIME = 10L;

private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();

private static final int CORE_THREAD_SIZE = CPU_COUNT + 1;

private static final int THREAD_SIZE = CPU_COUNT * 2 + 1;

private static final int VIEW_TAG_URL = R.id.view_tag_url;

private static final Object object = new Object();

private ThreadPoolExecutor mExecutor;

private Handler mMainHandler;

private Context mApplicationContext;

private static volatile ImageLoader mImageLoader;

private LruCache<String, Bitmap> mLruCache;

private DiskLruCache mDiskLruCache;

/**

• 磁盘缓存最大容量,50M
  */
  private static final long DISK_LRU_CACHE_MAX_SIZE = 50 * 1024 * 1024;

/**

• 当前进程的最大内存，取进程内存的1/8
  */
  private static final long MEMORY_CACHE_MAX_SIZE = Runtime.getRuntime().maxMemory() / 8;

public ImageLoader(Context context) {
if (context == null) {
throw new RuntimeException(“context can not be null !”);
}
mApplicationContext = context.getApplicationContext();

initLruCache();
initDiskLruCache();
initAsyncLoad();
}

public static ImageLoader with(Context context){
if (mImageLoader == null) {
synchronized (object) {
if (mImageLoader == null) {
mImageLoader = new ImageLoader(context);
}
}
}
return mImageLoader;
}

private void initAsyncLoad() {
mExecutor = new ThreadPoolExecutor(CORE_THREAD_SIZE, THREAD_SIZE,
KEEP_ALIVE_TIME, TimeUnit.SECONDS,
new LinkedBlockingQueue(), new ThreadFactory() {
private final AtomicInteger count = new AtomicInteger(1);
@Override
public Thread newThread(Runnable runnable) {
return new Thread(runnable, "load bitmap thread "+ count.getAndIncrement());
}
});

mMainHandler = new Handler(Looper.getMainLooper()){
@Override
public void handleMessage(@NonNull Message msg) {
LoadResult result = (LoadResult) msg.obj;
ImageView imageView = result.imageView;
Bitmap bitmap = result.bitmap;
String url = result.url;
if (imageView == null || bitmap == null) {
return;
}

//此判断是 避免 ImageView在列表中复用导致图片错位的问题
if (url.equals(imageView.getTag(VIEW_TAG_URL))) {
imageView.setImageBitmap(bitmap);
}else {
Log.w(TAG, “handleMessage: set image bitmap，but url has changed,ignore!”);
}
}
};
}

private void initLruCache() {

mLruCache = new LruCache<String, Bitmap>((int) MEMORY_CACHE_MAX_SIZE){
@Override
protected int sizeOf(String key, Bitmap value) {
//缓存对象bitmap的大小，单位要和MEMORY_CACHE_MAX_SIZE一致
return value.getByteCount();
}

@Override
protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue) {
//移除旧缓存时会调用，可以在这里进行像资源回收的工作。
}
};

}

private void initDiskLruCache() {

File externalCacheDir = mApplicationContext.getExternalCacheDir();
if (externalCacheDir != null) {
long usableSpace = externalCacheDir.getUsableSpace();
if (usableSpace < DISK_LRU_CACHE_MAX_SIZE){
//剩余空间不够了
Log.e(TAG, “initDiskLruCache: “+“UsableSpace=”+usableSpace+” , not enough(target 50M)，cannot creat diskLruCache！”);
return;
}
}

//一、创建DiskLruCache
//第一个参数是要存放的目录，这里选择外部缓存目录（若app卸载此目录也会删除）；
//第二个是版本一般设1；第三个是缓存节点的value数量一般也是1；
//第四个是最大缓存容量这里取50M
try {
this.mDiskLruCache = DiskLruCache.open(mApplicationContext.getExternalCacheDir(), 1, 1, DISK_LRU_CACHE_MAX_SIZE);
} catch (IOException e) {
e.printStackTrace();
Log.e(TAG, "initDiskLruCache: "+e.getMessage());
}
}

/**

• 缓存bitmap到内存
• @param url url
• @param bitmap bitmap
  */
  private void addBitmapMemoryCache(String url, Bitmap bitmap) {
  String key = UrlKeyTransformer.transform(url);
  if (mLruCache.get(key) == null && bitmap != null) {
  mLruCache.put(key,bitmap);
  }
  }

/**

• 从内存缓存加载bitmap
• @param url url
• @return
  */
  private Bitmap loadFromMemoryCache(String url) {
  return mLruCache.get(UrlKeyTransformer.transform(url));
  }

/**

• 从磁盘缓存加载bitmap（并添加到内存缓存）
• @param url url
• @param requestWidth 要求的宽
• @param requestHeight 要求的高
• @return bitmap
  */
  private Bitmap loadFromDiskCache(String url, int requestWidth, int requestHeight) throws IOException {
  if (Looper.myLooper()==Looper.getMainLooper()) {
  Log.w(TAG, “loadFromDiskCache from Main Thread may cause block ！”);
  }

if (mDiskLruCache == null) {
return null;
}
DiskLruCache.Snapshot snapshot = null;
String key = UrlKeyTransformer.transform(url);
snapshot = mDiskLruCache.get(key);
if (snapshot != null) {
FileInputStream inputStream = (FileInputStream)snapshot.getInputStream(0);

//Bitmap bitmap = BitmapFactory.decodeStream(inputStream);

//一般需要采样加载，但文件输入流是有序的文件流，采样时两次decodeStream影响文件流的位置属性，
//导致第二次decode是获取是null，为解决此问题，可用文件描述符。
FileDescriptor fd = inputStream.getFD();
Bitmap bitmap = BitmapSampleDecodeUtil.decodeFileDescriptor(fd, requestWidth, requestHeight);
addBitmapMemoryCache(url,bitmap);
return bitmap;
}

return null;
}

/**

• 从网路加载图片 到磁盘缓存（然后再从磁盘中采样加载）
• @param urlString urlString
• @param requestWidth 要求的宽
• @param requestHeight 要求的高
• @return Bitmap
  */
  private Bitmap loadFromHttp(String urlString, int requestWidth, int requestHeight) throws IOException {
  //线程检查，不能是主线程
  if (Looper.myLooper()==Looper.getMainLooper()) {
  throw new RuntimeException(“Do not loadFromHttp from Main Thread!”);
  }

if (mDiskLruCache == null) {
return null;
}

DiskLruCache.Editor editor = null;
editor = mDiskLruCache.edit(UrlKeyTransformer.transform(urlString));
if (editor != null) {
OutputStream outputStream = editor.newOutputStream(0);
if (downloadBitmapToStreamFromHttp(urlString, outputStream)) {
editor.commit();
}else {
editor.abort();
}
mDiskLruCache.flush();
}

return loadFromDiskCache(urlString, requestWidth, requestHeight);
}

/**

• 从网络下载图片到文件输入流
• @param urlString
• @param outputStream
• @return
  */
  private boolean downloadBitmapToStreamFromHttp(String urlString, OutputStream outputStream) {
  URL url = null;
  HttpURLConnection urlConnection = null;
  BufferedInputStream in = null;
  BufferedOutputStream out = null;
  try {
  url = new URL(urlString);
  urlConnection = (HttpURLConnection) url.openConnection();
  in = new BufferedInputStream(urlConnection.getInputStream());
  out = new BufferedOutputStream(outputStream);

int b;
while ((b=in.read()) != -1) {
//写入文件输入流
out.write(b);
}
return true;
} catch (IOException e) {
e.printStackTrace();
Log.e(TAG, "downloadBitmapToStreamFromHttp,failed : "+e.getMessage());
}finally {
if (urlConnection != null) {
urlConnection.disconnect();
}
IoUtil.close(in);
IoUtil.close(out);
}
return false;
}

/**

• 从网络直接下载bitmap（无缓存、无采样）
• @param urlString
• @return
  */
  private Bitmap downloadBitmapFromUrlDirectly(String urlString) {
  URL url;
  HttpURLConnection urlConnection = null;
  BufferedInputStream bufferedInputStream = null;
  try {
  url = new URL(urlString);
  urlConnection = (HttpURLConnection) url.openConnection();
  bufferedInputStream = new BufferedInputStream(urlConnection.getInputStream());
  return BitmapFactory.decodeStream(bufferedInputStream);
  } catch (IOException e) {
  e.printStackTrace();
  Log.e(TAG, "downloadBitmapFromUrlDirectly,failed : "+e.getMessage());
  }finally {
  if (urlConnection != null) {
  urlConnection.disconnect();
  }
  IoUtil.close(bufferedInputStream);
  }
  return null;
  }

public Bitmap loadBitmap(String url){
return loadBitmap(url,0,0);
}

/**

• 同步 加载bitmap
• 不能在主线程执行。加载时 先从内存缓存获取，有就返回bitmap，若没有就从磁盘缓存获取；
• 磁盘缓存有就返回bitmap并缓存到内存缓存，没有就请求网络；
• 网络请求回来，就缓存到磁盘缓存，然后从磁盘缓存获取返回。
• @return Bitmap
  */
  public Bitmap loadBitmap(String url, int requestWidth, int requestHeight){

Bitmap bitmap = loadFromMemoryCache(url);
if (bitmap != null) {
Log.d(TAG, “loadBitmap: loadFromMemoryCache, url:”+url);
return bitmap;
}

try {
bitmap = loadFromDiskCache(url, requestWidth, requestHeight);
} catch (IOException e) {
e.printStackTrace();
}
if (bitmap != null) {
Log.d(TAG, “loadBitmap: loadFromDiskCache, url:”+url);
return bitmap;
}

try {
bitmap = loadFromHttp(url, requestWidth, requestHeight);
} catch (IOException e) {
e.printStackTrace();
}
if (bitmap != null){
Log.d(TAG, “loadBitmap: loadFromHttp, url:”+url);
return bitmap;
}

if (mDiskLruCache == null) {
Log.d(TAG, “loadBitmap: diskLruCache is null，load bitmap from url directly！”);
bitmap = downloadBitmapFromUrlDirectly(url);
}

return bitmap;
}

public void loadBitmapAsync(final String url, final ImageView imageView){
loadBitmapAsync(url,imageView,0,0);
}

/**

• 异步 加载bitmap
• 外部可在任意线程执行，因为内部实现是在子线程(线程池)加载，
• 并且内部会通过Handler切到主线程，只需要传入view，内部就可直接绘制Bitmap到view。
• @param url
• @param imageView
• @param requestWidth
• @param requestHeight
  */
  public void loadBitmapAsync(final String url, final ImageView imageView, final int requestWidth, final int requestHeight){
  if (url == null || url.isEmpty() || imageView == null) {
  return;
  }

// 标记当前imageView要绘制图片的url
imageView.setTag(VIEW_TAG_URL, url);

mExecutor.execute(new Runnable() {
@Override
public void run() {

Bitmap loadBitmap = loadBitmap(url, requestWidth, requestHeight);

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

尾声

评论里面有些同学有疑问关于如何学习material design控件，我的建议是去GitHub搜，有很多同行给的例子，这些栗子足够入门。

有朋友说要是动真格的话，需要NDK以及JVM等的知识，首现**NDK并不是神秘的东西，**你跟着官方的步骤走一遍就知道什么回事了，无非就是一些代码格式以及原生/JAVA内存交互，进阶一点的有原生/JAVA线程交互，线程交互确实有点蛋疼，但平常避免用就好了，再说对于初学者来说关心NDK干嘛，据鄙人以前的经历，只在音视频通信和一个嵌入式信号处理（离线）的两个项目中用过，嵌入式信号处理是JAVA->NDK->.SO->MATLAB这样调用的我原来MATLAB的代码，其他的大多就用在游戏上了吧，一般的互联网公司会有人给你公司的SO包的。
至于JVM,该掌握的那部分，相信我，你会掌握的，不该你掌握的，有那些专门研究JVM的人来做，不如省省心有空看看计算机系统，编译原理。

一句话，平常多写多练，这是最基本的程序员的素质，尽量挤时间，读理论基础书籍，JVM不是未来30年唯一的虚拟机，JAVA也不一定再风靡未来30年工业界，其他的系统和语言也会雨后春笋冒出来，但你理论扎实会让你很快理解学会一个语言或者框架，你平常写的多会让你很快熟练的将新学的东西应用到实际中。
初学者，一句话，多练。

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

itHub搜**，有很多同行给的例子，这些栗子足够入门。

有朋友说要是动真格的话，需要NDK以及JVM等的知识，首现**NDK并不是神秘的东西，**你跟着官方的步骤走一遍就知道什么回事了，无非就是一些代码格式以及原生/JAVA内存交互，进阶一点的有原生/JAVA线程交互，线程交互确实有点蛋疼，但平常避免用就好了，再说对于初学者来说关心NDK干嘛，据鄙人以前的经历，只在音视频通信和一个嵌入式信号处理（离线）的两个项目中用过，嵌入式信号处理是JAVA->NDK->.SO->MATLAB这样调用的我原来MATLAB的代码，其他的大多就用在游戏上了吧，一般的互联网公司会有人给你公司的SO包的。
至于JVM,该掌握的那部分，相信我，你会掌握的，不该你掌握的，有那些专门研究JVM的人来做，不如省省心有空看看计算机系统，编译原理。

一句话，平常多写多练，这是最基本的程序员的素质，尽量挤时间，读理论基础书籍，JVM不是未来30年唯一的虚拟机，JAVA也不一定再风靡未来30年工业界，其他的系统和语言也会雨后春笋冒出来，但你理论扎实会让你很快理解学会一个语言或者框架，你平常写的多会让你很快熟练的将新学的东西应用到实际中。
初学者，一句话，多练。

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！