传送门 ☞ 轮子的专栏 ☞ 转载请注明 ☞ http://blog.csdn.net/leverage_1229
上周为360全景项目引入了图片缓存模块。因为是在Android4.0平台以上运作,出于惯性,都会在设计之前查阅相关资料,尽量避免拿一些以前2.3平台积累的经验来进行类比处理。开发文档中有一个BitmapFun的示例,仔细拜读了一下,虽说围绕着Bitmap的方方面面讲得都很深入,但感觉很难引入到当前项目中去。
现在的图片服务提供者基本上都来源于网络。对于应用平台而言,访问网络属于耗时操作。尤其是在移动终端设备上,它的显著表现为系统的延迟时间变长、用户交互性变差等。可以想象,一个携带着这些问题的应用在市场上是很难与同类产品竞争的。说明一下,本文借鉴了 Keegan小钢和安卓巴士的处理模板,主要针对的是4.0以上平台应用。2.3以前平台执行效果未知,请斟酌使用或直接略过:),当然更欢迎您把测试结果告知笔者。
1图片加载流程
首先,我们谈谈加载图片的流程,项目中的该模块处理流程如下: 在UI主线程中,从内存缓存中获取图片,找到后返回。找不到进入下一步;
在工作线程中,从磁盘缓存中获取图片,找到即返回并更新内存缓存。找不到进入下一步;
在工作线程中,从网络中获取图片,找到即返回并同时更新内存缓存和磁盘缓存。找不到显示默认以提示。
2内存缓存类(PanoMemCache)
这里使用Android提供的LruCache类,该类保存一个强引用来限制内容数量,每当Item被访问的时候,此Item就会移动到队列的头部。当cache已满的时候加入新的item时,在队列尾部的item会被回收。
- public class PanoMemoryCache {
- // LinkedHashMap初始容量
- private static final int INITIAL_CAPACITY = 16;
- // LinkedHashMap加载因子
- private static final int LOAD_FACTOR = 0.75f;
- // LinkedHashMap排序模式
- private static final boolean ACCESS_ORDER = true;
- // 软引用缓存
- private static LinkedHashMap<String, SoftReference<Bitmap>> mSoftCache;
- // 硬引用缓存
- private static LruCache<String, Bitmap> mLruCache;
- public PanoMemoryCache() {
- // 获取单个进程可用内存的最大值
- // 方式一:使用ActivityManager服务(计量单位为M)
- /*int memClass = ((ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE)).getMemoryClass();*/
- // 方式二:使用Runtime类(计量单位为Byte)
- final int memClass = (int) Runtime.getRuntime().maxMemory();
- // 设置为可用内存的1/4(按Byte计算)
- final int cacheSize = memClass / 4;
- mLruCache = new LruCache<String, Bitmap>(cacheSize) {
- @Override
- protected int sizeOf(String key, Bitmap value) {
- if(value != null) {
- // 计算存储bitmap所占用的字节数
- return value.getRowBytes() * value.getHeight();
- } else {
- return 0;
- }
- }
- @Override
- protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue) {
- if(oldValue != null) {
- // 当硬引用缓存容量已满时,会使用LRU算法将最近没有被使用的图片转入软引用缓存
- mSoftCache.put(key, new SoftReference<Bitmap>(oldValue));
- }
- }
- };
- /*
- * 第一个参数:初始容量(默认16)
- * 第二个参数:加载因子(默认0.75)
- * 第三个参数:排序模式(true:按访问次数排序;false:按插入顺序排序)
- */
- mSoftCache = new LinkedHashMap<String, SoftReference<Bitmap>>(INITIAL_CAPACITY, LOAD_FACTOR, ACCESS_ORDER) {
- private static final long serialVersionUID = 7237325113220820312L;
- @Override
- protected boolean removeEldestEntry(Entry<String, SoftReference<Bitmap>> eldest) {
- if(size() > SOFT_CACHE_SIZE) {
- return true;
- }
- return false;
- }
- };
- }
- /**
- * 从缓存中获取Bitmap
- * @param url
- * @return bitmap
- */
- public Bitmap getBitmapFromMem(String url) {
- Bitmap bitmap = null;
- // 先从硬引用缓存中获取
- synchronized (mLruCache) {
- bitmap = mLruCache.get(url);
- if(bitmap != null) {
- // 找到该Bitmap之后,将其移到LinkedHashMap的最前面,保证它在LRU算法中将被最后删除。
- mLruCache.remove(url);
- mLruCache.put(url, bitmap);
- return bitmap;
- }
- }
- // 再从软引用缓存中获取
- synchronized (mSoftCache) {
- SoftReference<Bitmap> bitmapReference = mSoftCache.get(url);
- if(bitmapReference != null) {
- bitmap = bitmapReference.get();
- if(bitmap != null) {
- // 找到该Bitmap之后,将它移到硬引用缓存。并从软引用缓存中删除。
- mLruCache.put(url, bitmap);
- mSoftCache.remove(url);
- return bitmap;
- } else {
- mSoftCache.remove(url);
- }
- }
- }
- return null;
- }
- /**
- * 添加Bitmap到内存缓存
- * @param url
- * @param bitmap
- */
- public void addBitmapToCache(String url, Bitmap bitmap) {
- if(bitmap != null) {
- synchronized (mLruCache) {
- mLruCache.put(url, bitmap);
- }
- }
- }
- /**
- * 清理软引用缓存
- */
- public void clearCache() {
- mSoftCache.clear();
- mSoftCache = null;
- }
- }
3磁盘缓存类(PanoDiskCache)
- public class PanoDiskCache {
- private static final String TAG = "PanoDiskCache";
- // 文件缓存目录
- private static final String CACHE_DIR = "panoCache";
- private static final String CACHE_FILE_SUFFIX = ".cache";
- private static final int MB = 1024 * 1024;
- private static final int CACHE_SIZE = 10; // 10M
- private static final int SDCARD_CACHE_THRESHOLD = 10;
- public PanoDiskCache() {
- // 清理文件缓存
- removeCache(getDiskCacheDir());
- }
- /**
- * 从磁盘缓存中获取Bitmap
- * @param url
- * @return
- */
- public Bitmap getBitmapFromDisk(String url) {
- String path = getDiskCacheDir() + File.separator + genCacheFileName(url);
- File file = new File(path);
- if(file.exists()) {
- Bitmap bitmap = BitmapFactory.decodeFile(path);
- if(bitmap == null) {
- file.delete();
- } else {
- updateLastModified(path);
- return bitmap;
- }
- }
- return null;
- }
- /**
- * 将Bitmap写入文件缓存
- * @param bitmap
- * @param url
- */
- public void addBitmapToCache(Bitmap bitmap, String url) {
- if(bitmap == null) {
- return;
- }
- // 判断当前SDCard上的剩余空间是否足够用于文件缓存
- if(SDCARD_CACHE_THRESHOLD > calculateFreeSpaceOnSd()) {
- return;
- }
- String fileName = genCacheFileName(url);
- String dir = getDiskCacheDir();
- File dirFile = new File(dir);
- if(!dirFile.exists()) {
- dirFile.mkdirs();
- }
- File file = new File(dir + File.separator + fileName);
- try {
- file.createNewFile();
- FileOutputStream out = new FileOutputStream(file);
- bitmap.compress(Bitmap.CompressFormat.JPEG, 100, out);
- out.flush();
- out.close();
- } catch (FileNotFoundException e) {
- Log.e(TAG, "FileNotFoundException");
- } catch (IOException e) {
- Log.e(TAG, "IOException");
- }
- }
- /**
- * 清理文件缓存
- * 当缓存文件总容量超过CACHE_SIZE或SDCard的剩余空间小于SDCARD_CACHE_THRESHOLD时,将删除40%最近没有被使用的文件
- * @param dirPath
- * @return
- */
- private boolean removeCache(String dirPath) {
- File dir = new File(dirPath);
- File[] files = dir.listFiles();
- if(files == null || files.length == 0) {
- return true;
- }
- if(!Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
- return false;
- }
- int dirSize = 0;
- for (int i = 0; i < files.length; i++) {
- if(files[i].getName().contains(CACHE_FILE_SUFFIX)) {
- dirSize += files[i].length();
- }
- }
- if(dirSize > CACHE_SIZE * MB || SDCARD_CACHE_THRESHOLD > calculateFreeSpaceOnSd()) {
- int removeFactor = (int) (0.4 * files.length + 1);
- Arrays.sort(files, new FileLastModifiedSort());
- for (int i = 0; i < removeFactor; i++) {
- if(files[i].getName().contains(CACHE_FILE_SUFFIX)) {
- files[i].delete();
- }
- }
- }
- if(calculateFreeSpaceOnSd() <= SDCARD_CACHE_THRESHOLD) {
- return false;
- }
- return true;
- }
- /**
- * 更新文件的最后修改时间
- * @param path
- */
- private void updateLastModified(String path) {
- File file = new File(path);
- long time = System.currentTimeMillis();
- file.setLastModified(time);
- }
- /**
- * 计算SDCard上的剩余空间
- * @return
- */
- private int calculateFreeSpaceOnSd() {
- StatFs stat = new StatFs(Environment.getExternalStorageDirectory().getPath());
- double sdFreeMB = ((double) stat.getAvailableBlocks() * (double) stat.getBlockSize()) / MB;
- return (int) sdFreeMB;
- }
- /**
- * 生成统一的磁盘文件后缀便于维护
- * 从URL中得到源文件名称,并为它追加缓存后缀名.cache
- * @param url
- * @return 文件存储后的名称
- */
- private String genCacheFileName(String url) {
- String[] strs = url.split(File.separator);
- return strs[strs.length - 1] + CACHE_FILE_SUFFIX;
- }
- /**
- * 获取磁盘缓存目录
- * @return
- */
- private String getDiskCacheDir() {
- return getSDPath() + File.separator + CACHE_DIR;
- }
- /**
- * 获取SDCard目录
- * @return
- */
- private String getSDPath() {
- File sdDir = null;
- // 判断SDCard是否存在
- boolean sdCardExist = Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
- if(sdCardExist) {
- // 获取SDCard根目录
- sdDir = Environment.getExternalStorageDirectory();
- }
- if(sdDir != null) {
- return sdDir.toString();
- } else {
- return "";
- }
- }
- /**
- * 根据文件最后修改时间进行排序
- */
- private class FileLastModifiedSort implements Comparator<File> {
- @Override
- public int compare(File lhs, File rhs) {
- if(lhs.lastModified() > rhs.lastModified()) {
- return 1;
- } else if(lhs.lastModified() == rhs.lastModified()) {
- return 0;
- } else {
- return -1;
- }
- }
- }
- }
4图片工具类(PanoUtils)
4.1从网络上获取图片:downloadBitmap()
- /**
- * 从网络上获取Bitmap,并进行适屏和分辨率处理。
- * @param context
- * @param url
- * @return
- */
- public static Bitmap downloadBitmap(Context context, String url) {
- HttpClient client = new DefaultHttpClient();
- HttpGet request = new HttpGet(url);
- try {
- HttpResponse response = client.execute(request);
- int statusCode = response.getStatusLine().getStatusCode();
- if(statusCode != HttpStatus.SC_OK) {
- Log.e(TAG, "Error " + statusCode + " while retrieving bitmap from " + url);
- return null;
- }
- HttpEntity entity = response.getEntity();
- if(entity != null) {
- InputStream in = null;
- try {
- in = entity.getContent();
- return scaleBitmap(context, readInputStream(in));
- } finally {
- if(in != null) {
- in.close();
- in = null;
- }
- entity.consumeContent();
- }
- }
- } catch (IOException e) {
- request.abort();
- Log.e(TAG, "I/O error while retrieving bitmap from " + url, e);
- } catch (IllegalStateException e) {
- request.abort();
- Log.e(TAG, "Incorrect URL: " + url);
- } catch (Exception e) {
- request.abort();
- Log.e(TAG, "Error while retrieving bitmap from " + url, e);
- } finally {
- client.getConnectionManager().shutdown();
- }
- return null;
- }
4.2从输入流读取字节数组,看起来是不是很眼熟啊!
- public static byte[] readInputStream(InputStream in) throws Exception {
- ByteArrayOutputStream out = new ByteArrayOutputStream();
- byte[] buffer = new byte[1024];
- int len = 0;
- while((len = in.read(buffer)) != -1) {
- out.write(buffer, 0, len);
- }
- in.close();
- return out.toByteArray();
- }
4.3对下载的源图片进行适屏处理,这也是必须的:)
- /**
- * 按使用设备屏幕和纹理尺寸适配Bitmap
- * @param context
- * @param in
- * @return
- */
- private static Bitmap scaleBitmap(Context context, byte[] data) {
- WindowManager windowMgr = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
- DisplayMetrics outMetrics = new DisplayMetrics();
- windowMgr.getDefaultDisplay().getMetrics(outMetrics);
- int scrWidth = outMetrics.widthPixels;
- int scrHeight = outMetrics.heightPixels;
- BitmapFactory.Options options = new BitmapFactory.Options();
- options.inJustDecodeBounds = true;
- Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length, options);
- int imgWidth = options.outWidth;
- int imgHeight = options.outHeight;
- if(imgWidth > scrWidth || imgHeight > scrHeight) {
- options.inSampleSize = calculateInSampleSize(options, scrWidth, scrHeight);
- }
- options.inJustDecodeBounds = false;
- bitmap = BitmapFactory.decodeByteArray(data, 0, data.length, options);
- // 根据业务的需要,在此处还可以进一步做处理
- ...
- return bitmap;
- }
- /**
- * 计算Bitmap抽样倍数
- * @param options
- * @param reqWidth
- * @param reqHeight
- * @return
- */
- public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
- // 原始图片宽高
- final int height = options.outHeight;
- final int width = options.outWidth;
- int inSampleSize = 1;
- if (height > reqHeight || width > reqWidth) {
- // 计算目标宽高与原始宽高的比值
- final int heightRatio = Math.round((float) height / (float) reqHeight);
- final int widthRatio = Math.round((float) width / (float) reqWidth);
- // 选择两个比值中较小的作为inSampleSize的值
- inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
- if(inSampleSize < 1) {
- inSampleSize = 1;
- }
- }
- return inSampleSize;
- }
5使用decodeByteArray()还是decodeStream()?
讲到这里,有童鞋可能会问我为什么使用BitmapFactory.decodeByteArray(data, 0, data.length, opts)来创建Bitmap,而非使用BitmapFactory.decodeStream(is, null, opts)。你这样做不是要多写一个静态方法readInputStream()吗?没错,decodeStream()确实是该使用情景下的首选方法,但是在有些情形下,它会导致图片资源不能即时获取,或者说图片被它偷偷地缓存起来,交还给我们的时间有点长。但是延迟性是致命的,我们等不起。所以在这里选用decodeByteArray()获取,它直接从字节数组中获取,贴近于底层IO、脱离平台限制、使用起来风险更小。
6引入缓存机制后获取图片的方法
- /**
- * 加载Bitmap
- * @param url
- * @return
- */
- private Bitmap loadBitmap(String url) {
- // 从内存缓存中获取,推荐在主UI线程中进行
- Bitmap bitmap = memCache.getBitmapFromMem(url);
- if(bitmap == null) {
- // 从文件缓存中获取,推荐在工作线程中进行
- bitmap = diskCache.getBitmapFromDisk(url);
- if(bitmap == null) {
- // 从网络上获取,不用推荐了吧,地球人都知道~_~
- bitmap = PanoUtils.downloadBitmap(this, url);
- if(bitmap != null) {
- diskCache.addBitmapToCache(bitmap, url);
- memCache.addBitmapToCache(url, bitmap);
- }
- } else {
- memCache.addBitmapToCache(url, bitmap);
- }
- }
- return bitmap;
- }
7工作线程池化管理
有关多线程的切换问题以及在UI线程中执行loadBitmap()方法无效的问题,请参见另一篇博文: 使用严苛模式打破Android4.0以上平台应用中UI主线程的“独断专行”。有关工作线程的处理方式,这里推荐使用定制线程池的方式,核心代码如下:
- // 线程池初始容量
- private static final int POOL_SIZE = 4;
- private ExecutorService executorService;
- @Override
- public void onCreate(Bundle savedInstanceState) {
- super.onCreate(savedInstanceState);
- // 获取当前使用设备的CPU个数
- int cpuNums = Runtime.getRuntime().availableProcessors();
- // 预开启线程池数目
- executorService = Executors.newFixedThreadPool(cpuNums * POOL_SIZE);
- ...
- executorService.submit(new Runnable() {
- // 此处执行一些耗时工作,不要涉及UI工作。如果遇到,直接转交UI主线程
- pano.setImage(loadBitmap(url));
- });
- ...
- }
我们知道,线程构造也是比较耗资源的。一定要对其进行有效的管理和维护。千万不要随意而行,一张图片的工作线程不搭理也许没什么,当使用场景变为ListView和GridView时,线程池化工作就显得尤为重要了。Android不是提供了AsyncTask吗?为什么不用它?其实AsyncTask底层也是靠线程池支持的,它默认分配的线程数是128,是远大于我们定制的executorService。
使用严苛模式打破Android4.0以上平台应用中UI主线程的“独断专行”
最近单位来了一个Android4.1平台的360街景项目。在编写该项目demo的过程中,为了省事,打算直接在UI线程中访问网络数据源并生成Bitmap以填充相应的视图。访问网络模块的封装采用了HttpClient的方式进行构建。编写完工后执行程序,发现视图显示的还是本地的默认图样。在确认了网络权限已被开启的情况下,我开始怀疑是不是HttpClient封装的粒度过大,导致其适用范围受限的问题。于是干脆采用Java平台最底层的Socket套接字方式来实现网络访问,可是结果还是一样的,仍旧无法得到网络数据。经过调试发现,在客户端发出请求之后,根本无法连接到服务端,也就无法解析后续的服务端的响应内容了。
以前在Android2.3.3平台上研发怎么没有这个现象?难道是Android4.0的单线程模式的“禁令”较之以往更为严格了。为了使应用程序具有更好的交互性和更少的延迟时间,强势要求开发人员在UI主线程中只能执行与UI相关的工作(如:更新视图、与用户交互等),其他方面的工作一律禁止执行。为了验证这个相反,在stackoverflow.com检索了相关议题,从一位Google工程师的解答中基本得到了印证。也就是说,如果你非要在UI主线程中执行其他工作(如:访问网络、文件操作等),其实有这种编程强迫症的人在项目初期还是很多的,笔者就是其中的一位。你需要为UI主线程所在的Activity设置线程策略,告知平台请赋予我在UI主线程中进行其他工作的权限。具体做法有如下:
在你的Application、Activity或其它应用容器中添加如下代码:
- public void onCreate() {
- if (DEVELOPER_MODE) {
- StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
- .detectDiskReads() // 捕捉读取磁盘
- .detectDiskWrites() // 捕捉写入磁盘
- .detectNetwork() // 捕捉网络访问 或使用detectAll() 火力全开
- .penaltyLog() // 捕捉LogCat日志
- .build());
- StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
- .detectLeakedSqlLiteObjects()
- .detectLeakedClosableObjects()
- .penaltyLog()
- .penaltyDeath()
- .build());
- }
- super.onCreate();
- }
StrictMode类
StrictMode是一个开发者工具类,从Android 2.3平台开始被引入。可以用于捕捉发生在应用程序UI主线程中耗时的IO操作、网络访问或方法调用;也可以用来改进应用程序,使得UI主线程在处理IO操作和访问网络时显得更平滑,避免其被阻塞,导致ANR警告。更多有关StrictMode的信息,请参见http://developer.android.com/reference/android/os/StrictMode.html。
这种非常规的做法,是在项目初期和开发模式下为了达到更高的效率,而采取一种提高生产效率做法。在产品交付和运维时,我们还是要严格遵守Android平台进程与线程安全管理机制。接下来是在实际开发中应该遵循的两个原则:
UI主线程
在UI主线程中,只处理与UI相关及用户交互的工作,耗时的工作一律交由后台工作线程去搭理。常见的耗时工作处理方式有:
AsyncTask;
Handler、MessageQueue、Looper;
ExecutorService(execute/submit)
工作线程
在工作线程中,只做自己分内的事。决不干涉UI主线程的工作。在执行过程中如果存在涉及到UI的操作(如:更新视图、重绘等),一律将其转交给UI主线程进行处理。常见的转交方式有:
Activity.runOnUiThread(new Runnable(){...});
View.post(new Runnable(){...});
View.postDelay(Runnable(){...},long)
示例
最后,提供AsyncMultiThreadActivity演示Android多线程与UI交互的方式,仅供读者参考使用。
- public class AsyncMultiThreadActivity extends Activity {
- private TextView txView;
- private Button button;
- /** Called when the activity is first created. */
- @Override
- public void onCreate(Bundle savedInstanceState) {
- Log.i("RootyInfo", "oncreate");
- super.onCreate(savedInstanceState);
- setContentView(R.layout.main);
- txView=(TextView)findViewById(R.id.textView1);
- button=(Button)findViewById(R.id.button1);
- button.setOnClickListener(new OnClickListener() {
- @Override
- public void onClick(View v) {
- //创建一个用于展示前三种后台线程和UI线程交互的线程
- new TestThread(MainActivity.this).start();
- //创建一个用于展示AsyncTask实现交互的TestAsyncTask
- new TestAsyncTask().execute("Test"," AsyncTask");
- }
- });
- }
- class TestAsyncTask extends AsyncTask<String, Integer, String> {
- //TestAsyncTask被后台线程执行后,被UI线程被调用,一般用于初始化界面控件,如进度条
- @Override
- protected void onPreExecute() {
- super.onPreExecute();
- }
- //doInBackground执行完后由UI线程调用,用于更新界面操作
- @Override
- protected void onPostExecute(String result) {
- txView.setText(result);
- super.onPostExecute(result);
- }
- //在PreExcute执行后被启动AysncTask的后台线程调用,将结果返回给UI线程
- @Override
- protected String doInBackground(String... params) {
- StringBuffer sb=new StringBuffer();
- for (String string : params) {
- sb.append(string);
- }
- return sb.toString();
- }
- }
- //用于线程间通信的Handler
- class TestHandler extends Handler {
- public TestHandler(Looper looper) {
- super(looper);
- }
- @Override
- public void handleMessage(Message msg) {
- System.out.println("123");
- txView.setText((String)msg.getData().get("tag"));
- super.handleMessage(msg);
- }
- }
- //后台线程类
- class TestThread extends Thread {
- Activity activity;
- public TestThread(Activity activity) {
- this.activity = activity;
- }
- @Override
- public void run() {
- // 演示Activity.runOnUIThread(Runnable)方法的实现
- activity.runOnUiThread(new Runnable() {
- @Override
- public void run() {
- txView.setText("Test runOnUIThread");
- }
- });
- // 演示Activity.runOnUIThread(Runnable)方法的实现
- txView.post(new Runnable() {
- @Override
- public void run() {
- txView.setText("Test View.post(Runnable)");
- }
- });
- // 演示Activity.runOnUIThread(Runnable)方法的实现
- txView.postDelayed(new Runnable() {
- @Override
- public void run() {
- txView.setText("Test View.postDelay(Runnable,long)");
- }
- }, 1000);
- // 演示Handler方法的实现
- Message msg=new Message();
- Bundle bundle=new Bundle();
- bundle.putString("tag", "Test Handler");
- msg.setData(bundle);
- new TestHandler(Looper.getMainLooper()).sendMessage(msg);
- super.run();
- }
- }
- }