[关闭]
@zyl06 2018-09-21T18:03:49.000000Z 字数 5514 阅读 1612

严选 Android 日志记录小优化

Android

0 背景现状

APP 当中有这样的场景：记录错误、警告错误日志至本地文本，如用户支付失败、H5 内容加载失败、请求超时、登录失败、json 解析异常等。目前我们的做法，每次写入一个文件，写满 1M，新启一个文件写，最多 3 个文件，3个文件都写满，将最老的文件清空。

为避免多线程竞争文件操作，将写文件、文件上传等都放在一个单线程池中处理。

  1. public void write(final File file, @NonNull final String msg) {
  2.     ThreadUtil.runOnSingleThread(new Runnable() {
  3.         @Override
  4.         public void run() {
  5.             syncWrite(file, msg);
  6.         }
  7.     });
  8. }
  10. private void syncWrite(File file, @NonNull String msg) {
  11.     if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
  12.         FileOutputStream fos = null;
  14.         long timestamp = SystemUtil.getCurrentTimeMillis();
  15.         StringBuilder sb = new StringBuilder(4 * 1024);
  16.         String currentTime = StringUtil.formatTime("yyyy-MM-dd HH:mm:ss", timestamp);
  17.         sb.append(StringUtil.add("\n[", currentTime, " utc0000]"));
  18.         sb.append(" ");
  19.         appendTopPageInfo(sb);
  20.         sb.append("  ");
  21.         sb.append(msg);
  22.         sb.append("\n\n");
  24.         try {
  25.             fos = new FileOutputStream(file.getPath(), true);
  26.             fos.write(sb.toString().getBytes());
  27.         } catch (IOException e) {
  28.             e.printStackTrace();
  29.         } finally {
  30.             Disposable.dispose(fos);
  31.         }
  32.     }
  33. }

写测试代码查看性能：

  1. private void test() {
  2.     String msg = "test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
  4.     start = System.currentTimeMillis();
  5.     for (int i=0; i<5000; i++) {
  6.         FeedbackUtil.syncSaveFeedbackLogInfo2File(msg);
  7.     }
  8.     Log.i("JOURNAL", "old cost " + (System.currentTimeMillis() - start));
  9. }

测试代码 0-0

  1. 09-14 16:52:43.310 14421-14421/com.netease.yanxuan I/JOURNAL: old cost 2294

测试查看测试结果，可以发现写操作耗时为 2294ms。重新分析上面的写文件操作。一次写文件过程如下：

  1. 进程调用库函数向内核发起读文件请求；
  2. 内核通过检查进程的文件描述符定位到虚拟文件系统的已打开文件列表表项；
  3. 调用该文件可用的系统调用函数 read()
  4. read() 函数通过文件表项链接到目录项模块，根据传入的文件路径，在目录项模块中检索，找到该文件的inode；
  5. 在 inode 中，通过文件内容偏移量计算出要读取的页；
  6. 通过 inode 找到文件对应的 address_space，在 address_space 中查询对应页的页缓存是否存在；
  7. 如果页缓存命中，直接把文件内容修改更新在页缓存的页中。写文件就结束了。这时候文件修改位于页缓存，并没有写回到磁盘文件中去。
  8. 如果页缓存缺失，那么产生一个页缺失异常，创建一个页缓存页，同时通过 inode 找到文件该页的磁盘地址，读取相应的页填充该缓存页。此时缓存页命中，进行第 7 步；
  9. 一个页缓存中的页如果被修改，那么会被标记成脏页。脏页需要写回到磁盘中的文件块。有两种方式可以把脏页写回磁盘：
    • 手动调用 sync() 或者 fsync() 系统调用把脏页写回
    • pdflush进程会定时把脏页写回到磁盘

以上写过程摘自 从内核文件系统看文件读写过程

总结以上可以发现有 2 处性能消耗的地方：

  1. 以上一次写文件操作，会发生 2 次拷贝操作，用户内存数据拷贝至内核页缓存，内核页缓存写入磁盘；
  2. 由于写日志是非常频繁的操作，同时每次写的内容都是很小的，可以理解程序会非常频繁的对同一个文件执行上述的 1 ~ 8 步骤。

而写性能低下导致的问题除了 cpu 占用，更容易导致写日志的线程队列过长，甚至溢出导致丢弃最老的任务，也容易发生进程被杀时，日志的丢失。

1 优化

针对性能消耗 1，如何减少 2 次拷贝操作，我们能想到使用 mmap，通过文件内存映射的方式将 2 次拷贝操作减少至 1 次。

  1. mmap是一种内存映射文件的方法，即将一个文件或者其它对象映射到进程的地址空间，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一对映关系。
  2. 实现这样的映射关系后，进程就可以采用指针的方式读写操作这一段内存，而系统会自动回写脏页面到对应的文件磁盘上，即完成了对文件的操作

摘自 认真分析mmap：是什么 为什么 怎么用

然而根据现在的使用场景，数据写操作虽然频繁，然而每次写的数据量都比较小，同时也不知道下次写是何时会发生，可能 1ms 后就立即触发，也可能 1 分钟后。而 mmap 并不适合小数据的操作，即每次写的时候都创建一次，length 是每次写的小数据长度。

  1. c 方法原型
  2. void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);
  4. java 方法原型
  5. public abstract MappedByteBuffer map(MapMode mode, long position, long size)

查看测试代码：

  1. protected void test() {
  3.     String content = "aaaaaaaaaaaassssdfsfasfsdsdfsegwegegwgs";
  5.     long start = System.currentTimeMillis();
  6.     oldWrite(content);
  7.     Log.i("TEST", "old: " + (System.currentTimeMillis() - start));
  9.     start = System.currentTimeMillis();
  10.     newWrite1(content);
  11.     Log.i("TEST", "new1: " + (System.currentTimeMillis() - start));
  13.     start = System.currentTimeMillis();
  14.     newWrite(content);
  15.     Log.i("TEST", "new: " + (System.currentTimeMillis() - start));
  16. }
  18. private void oldWrite(String content) {
  19.     String path = StorageUtil.getWritePath("oldwrite.txt", StorageType.TYPE_FILE);
  21.     for (int i = 0; i < 1000; i++) {
  22.         File file = new File(path);
  23.         FileOutputStream os = null;
  24.         try {
  25.             os = new FileOutputStream(file, true);
  26.             os.write(content.getBytes());
  27.         } catch (IOException e) {
  28.             Log.e("TEST", "old: " + e.toString());
  29.         } finally {
  30.             Disposable.dispose(os);
  31.         }
  32.     }
  33. }
  35. private void newWrite(String content) {
  36.     String path = StorageUtil.getWritePath("newwrite.txt", StorageType.TYPE_FILE);
  37.     File file = new File(path);
  39.     RandomAccessFile raf = null;
  40.     try {
  41.         raf = new RandomAccessFile(file, "rw");
  42.         MappedByteBuffer buff = raf.getChannel().map(FileChannel.MapMode.READ_WRITE, 0, 1024 * 1024);
  43.         for (int i = 0; i < 1000; i++) {
  44.             buff.put(content.getBytes());
  45.         }
  46.         buff.force();
  47.         buff.flip();
  48.     } catch (Exception e) {
  49.         Log.e("TEST", "new: " + e.toString());
  50.     } finally {
  51.         Disposable.dispose(raf);
  52.     }
  53. }
  55. private void newWrite1(String content) {
  56.     String path = StorageUtil.getWritePath("newwrite1.txt", StorageType.TYPE_FILE);
  57.     File file = new File(path);
  59.     for (int i = 0; i < 1000; i++) {
  60.         RandomAccessFile raf = null;
  61.         try {
  62.             raf = new RandomAccessFile(file, "rw");
  63.             byte[] bytes = content.getBytes();
  64.             MappedByteBuffer buff = raf.getChannel().map(FileChannel.MapMode.READ_WRITE, raf.length(), bytes.length);
  65.             buff.put(content.getBytes());
  67.             buff.force();
  68.             buff.flip();
  69.         } catch (Exception e) {
  70.             Log.e("TEST", "new: " + e.toString());
  71.         } finally {
  72.             Disposable.dispose(raf);
  73.         }
  74.     }
  75. }

测试代码 1-0

查看测试结果：

  1. 09-14 18:06:47.205 7311-7311/com.netease.yanxuan I/TEST: old: 129
  2. 09-14 18:06:50.899 7311-7311/com.netease.yanxuan I/TEST: new1: 3694
  3. 09-14 18:06:47.076 7311-7311/com.netease.yanxuan I/TEST: new: 27

由上我们可以发现，执行 1000 次字符串写，mmap 执行一次大数据写性能最好，普通文件写操作要慢 4 倍多，而 mmap 执行多次小数据写则性能会差很多。

查看文件可以发现，一次性 mmap 1M 的文件，但仅写入 40K 左右的数据，最后文件大小还是 1M

Alt pic

写入生成的文件

Alt pic

1M 文件的内容

针对以上情况，一种解决方法是使用内存缓存，业务层写日志时并不是立马写入文件，而是写入内存缓存中，等内存缓存到达一定大小，或者定期轮训触发写操作。虽然能很好的优化写性能问题，同时可以根据内存缓存的大小，可以按需写入文件，不会出现文件有无效数据的情况。然而内存缓存的延迟写入，在进程被杀的情况下，极大的增加了丢日志的情况。

所以这里采用另外的思路，构建写消息队列，并且发送 10ms 延迟关闭 buff 消息，保证在频繁写操作下，文件描述符不会被频繁关闭和打开，同时 10ms 内无写操作时，能及时关闭文件描述符，避免内存泄露。另外为准确确认文件大小，在文件头 4 个字节写入文件内容的真实大小。

Alt pic

日志文件

Alt pic

写日志流程

同最初的测试代码，写日志 5000 次到日志文件

  1. private void test() {
  2.     String msg = "test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
  4.     start = System.currentTimeMillis();
  5.     for (int i=0; i<5000; i++) {
  6.         FeedbackUtil.syncSaveLogInfo2File(msg);
  7.     }
  8.     Log.i("JOURNAL", "old cost " + (System.currentTimeMillis() - start));
  10.     start = System.currentTimeMillis();
  11.     for (int i = 0; i < 5000; i++) {
  12.         NewFeedbackUtil.syncSaveLogInfo2File(msg);
  13.     }
  14.     Log.i("JOURNAL", "new cost " + (System.currentTimeMillis() - start));
  15. }

测试代码 1-1

  1. 09-15 09:09:46.744 4450-4450/com.netease.yanxuan I/JOURNAL: old cost 2319
  2. 09-15 09:09:44.425 4450-4450/com.netease.yanxuan I/JOURNAL: new cost 1285

最后能发现日志写提升 80%，至于相比测试代码 1-0 的性能提升 4 倍，为何会差这么多，是因为除了纯粹的写之外，真实日志代码中需要获取额外的日志信息，如时间、当前页面信息等，同时优化的日志文件严格控制了应用层设置的文件上限，而老的日志写并没有严格控制上限。

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注