基础知识记录：OOM异常出现的情况与处理方式

1、 查询内存情况

：通过Android Studio的Memory Monitor查看内存中Dalvik Heap的实时变化

2、 异常出现的情况

：当之前分配的内存+新分配的内存超出系统分配的内存时即 getMemoryClass()获取到的内存数据时就超出了内存，出现OOM

3、 异常出现的原因

：1、无限循环；

2、加载的图片过大或者图片过多；

3、无限制创建各种对象；

4、等

4、 异常处理方法

：1、减少对象的使用，尽量使用轻量级的（使用更加轻量的数据结构、少使用静态与枚举等）

2、使用图片是可进行压缩（大小、质量压缩），使用3级缓存机制，使用LRU的机制来缓存处理好的Bitmap图片，减少内存的付出

3、listview与gridview、recyclerview等加载数据时，使用convertView进行复用。

4、一些系统自带的资源，尽量使用系统的，可以减小内存，也能减小apk的大小。

知识点：LRU机制

计算机中有一个概念，我们用缓存来存放以前读取的数据，而不是直接丢掉，这样，再次读取的时候，可以直接在缓存里面取，而不用再重新查找一遍，这样系统的反应能力会有很大提高。但是，当我们读取的个数特别大的时候，我们不可能把所有已经读取的数据都放在缓存里，毕竟内存大小是一定的，我们一般把最近常读取的放在缓存里（相当于我们把最近联系的朋友的姓名和电话放在大脑里一样）。现在，我们就来研究这样一种缓存机制。

LRU缓存利用了这样的一种思想。LRU是Least Recently Used 的缩写，翻译过来就是“最近最少使用”，也就是说，LRU缓存把最近最少使用的数据移除，让给最新读取的数据。而往往最常读取的，也是读取次数最多的，所以，利用LRU缓存，我们能够提高系统的performance.

实现：

要实现LRU缓存，我们首先要用到一个类 LinkedHashMap。 用这个类有两大好处：一是它本身已经实现了按照访问顺序的存储，也就是说，最近读取的会放在最前面，最最不常读取的会放在最后（当然，它也可以实现按照插入顺序存储）。第二，LinkedHashMap本身有一个方法用于判断是否需要移除最不常读取的数，

其中实现方式可使用双链表 + hashtable来实现

1.  public class LRUCache {
2.
3.      private int cacheSize;
4.      private Hashtable<Object, Entry> nodes;//缓存容器
5.      private int currentSize;
6.      private Entry first;//链表头
7.      private Entry last;//链表尾
8.
9.      public LRUCache(int i) {
10.         currentSize = 0;
11.         cacheSize = i;
12.         nodes = new Hashtable<Object, Entry>(i);//缓存容器
13.     }
14.
15.     /**
16.      * 获取缓存中对象,并把它放在最前面
17.      */
18.     public Entry get(Object key) {
19.         Entry node = nodes.get(key);
20.         if (node != null) {
21.             moveToHead(node);
22.             return node;
23.         } else {
24.             return null;
25.         }
26.     }
27.
28.     /**
29.      * 添加 entry到hashtable, 并把entry
30.      */
31.     public void put(Object key, Object value) {
32.         //先查看hashtable是否存在该entry, 如果存在，则只更新其value
33.         Entry node = nodes.get(key);
34.
35.         if (node == null) {
36.             //缓存容器是否已经超过大小.
37.             if (currentSize >= cacheSize) {
38.                 nodes.remove(last.key);
39.                 removeLast();
40.             } else {
41.                 currentSize++;
42.             }
43.             node = new Entry();
44.         }
45.         node.value = value;
46.         //将最新使用的节点放到链表头，表示最新使用的.
47.         moveToHead(node);
48.         nodes.put(key, node);
49.     }
50.
51.     /**
52.      * 将entry删除, 注意：删除操作只有在cache满了才会被执行
53.      */
54.     public void remove(Object key) {
55.         Entry node = nodes.get(key);
56.         //在链表中删除
57.         if (node != null) {
58.             if (node.prev != null) {
59.                 node.prev.next = node.next;
60.             }
61.             if (node.next != null) {
62.                 node.next.prev = node.prev;
63.             }
64.             if (last == node)
65.                 last = node.prev;
66.             if (first == node)
67.                 first = node.next;
68.         }
69.         //在hashtable中删除
70.         nodes.remove(key);
71.     }
72.
73.     /**
74.      * 删除链表尾部节点，即使用最后 使用的entry
75.      */
76.     private void removeLast() {
77.         //链表尾不为空,则将链表尾指向null. 删除连表尾（删除最少使用的缓存对象）
78.         if (last != null) {
79.             if (last.prev != null)
80.                 last.prev.next = null;
81.             else
82.                 first = null;
83.             last = last.prev;
84.         }
85.     }
86.
87.     /**
88.      * 移动到链表头，表示这个节点是最新使用过的
89.      */
90.     private void moveToHead(Entry node) {
91.         if (node == first)
92.             return;
93.         if (node.prev != null)
94.             node.prev.next = node.next;
95.         if (node.next != null)
96.             node.next.prev = node.prev;
97.         if (last == node)
98.             last = node.prev;
99.         if (first != null) {
100.                node.next = first;
101.                first.prev = node;
102.            }
103.            first = node;
104.            node.prev = null;
105.            if (last == null)
106.                last = first;
107.        }
108.        /*
109.         * 清空缓存
110.         */
111.        public void clear() {
112.            first = null;
113.            last = null;
114.            currentSize = 0;
115.        }
116.
117.    }
118.
119.    class Entry {
120.        Entry prev;//前一节点
121.        Entry next;//后一节点
122.        Object value;//值
123.        Object key;//键
124.    }