HashMap 源碼解析

源碼學(xué)習(xí)韧掩，邊看源碼邊加注釋净神，邊debug智亮，邊理解俄删。

基本屬性

常量

  • DEFAULT_INITIAL_CAPACITY：默認數(shù)組的初始容量 - 必須是2的冪宏怔。
  • MAXIMUM_CAPACITY：數(shù)組的最大容量
  • DEFAULT_LOAD_FACTOR：哈希表的負載因子0.75
  • TREEIFY_THRESHOLD：在一個桶內(nèi)由樹轉(zhuǎn)換成鏈表的閾值
  • UNTREEIFY_THRESHOLD：又樹轉(zhuǎn)換成鏈表的閾值
  • MIN_TREEIFY_CAPACITY：在數(shù)組長度大于或等于64時才會進行鏈表轉(zhuǎn)換成樹的操作，否則直接擴容

全局變量

  • table：數(shù)組對象
  • size：HashMap大小
  • modCount：操作HashMap的總數(shù) for fast-fail
  • threshold： 擴容的閾值
  • loadFactor：哈希表的負載因子畴椰，默認是DEFAULT_LOAD_FACTOR值

數(shù)據(jù)結(jié)構(gòu)

HashMap的數(shù)據(jù)結(jié)構(gòu)在jdk1.8之前采用的是數(shù)組+鏈表臊诊，jdk1.8之后采用了數(shù)組+鏈表/紅黑樹的結(jié)構(gòu)，如圖：


HashMap的數(shù)據(jù)結(jié)構(gòu)

如圖所示當(dāng)鏈表長度大于8時斜脂，鏈表轉(zhuǎn)換成紅黑樹抓艳。

在jdk1.8中存儲數(shù)據(jù)的節(jié)點有兩種一種是鏈表節(jié)點Node一種是樹節(jié)點TreeNode：

Node：

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;
...

TreeNode：

 static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;  // red-black tree links
        TreeNode<K,V> left;
        TreeNode<K,V> right;
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red;
...
TeeeNode繼承關(guān)系.png

通過上面的繼承關(guān)系我們發(fā)現(xiàn)TreeNode是繼承自Node的。

如果元素小于8個帚戳，鏈表查詢成本高玷或，新增成本低
如果元素大于8個儡首，紅黑樹查詢成本低，新增成本高

常見的使用方式

    @Test
    public void testHashMap() {
        Map<String, Object> map = new HashMap<>();
        map.put("1", "1");
        map.get("1");
        map.size();
    }

這是我們使用HashMap最常見的使用方式偏友，下面我就來看下每一步都是怎么實現(xiàn)的蔬胯。測試代碼:

public class HashMapTest {

    public static void main(String[] args) {
        Map<User, Object> map = new HashMap<>();
        for (; ; ) {
            map.put(new User(), map.size());
            if (map.size() > 1000) {
                break;
            }
        }

        map.size();
    }

    static class User {
        @Override
        public int hashCode() {
            return 1;
        }
    }
}

構(gòu)造函數(shù)

我們使用HashMap第一步是先創(chuàng)建一個HashMap，從上面的語句來看HashMap繼承自Map接口位他，下面我們開看看new HashMap<>()都做了些什么：

    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

原來啥都沒干氛濒，就只是對一個成員變量賦了一個初值《焖瑁看來數(shù)組的初始化和鏈表的初始化等都是在后面發(fā)生的泼橘。

put() 方法

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

hash() 方法

    static final int hash(Object key) {
        int h;
        // 計算key.hashCode（）并將更高位的散列擴展（XOR）降低。采用位運算主要是是加快計算速度
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

putVal() 方法

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        // 數(shù)組對象
        Node<K, V>[] tab;
        // 通過key值找出對應(yīng)數(shù)組索引位的數(shù)據(jù) p = tab[i = (n - 1) & hash]
        Node<K, V> p;
        // n 表示數(shù)組長度迈勋， i表示key值在數(shù)組上的索引位
        int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            // 判斷數(shù)組是否為null炬灭，如果是則調(diào)用resize()方法進行初始化
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            // (n-1)&hash= hash%(n-1)，通過該公式找出該值在數(shù)組上的索引位靡菇。 保證不發(fā)生數(shù)組越界重归。
            // 如果該索引位為null，則直接將數(shù)據(jù)放到該索引位
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K, V> e;
            K k;
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                // 表示key完全相同
                e = p;
            else if (p instanceof TreeNode)
                // 桶內(nèi)已經(jīng)是紅黑樹節(jié)點
                e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
            else {
                // 桶內(nèi)還是鏈表節(jié)點
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        // 通過自旋找到尾部節(jié)點厦凤，并將新數(shù)據(jù)添加在尾部節(jié)點后面
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            // 如果鏈表內(nèi)的數(shù)據(jù)已經(jīng)超過8個則嘗試將鏈表轉(zhuǎn)成紅黑樹（其實這個時候鏈表已經(jīng)有9個節(jié)點了鼻吮，最后一個節(jié)點是上一步添加進去的）
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        // key完全相同則走后面的value替換流程
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    // 在key完全相同的情況下，用新數(shù)據(jù)去覆蓋老數(shù)據(jù)的value值较鼓，并返回老數(shù)據(jù)的value值
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        // 判斷如果hash表的總數(shù)大于擴容閾值的時候需要進行擴容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

putTreeVal() 插入紅黑樹節(jié)點

final TreeNode<K, V> putTreeVal(HashMap<K, V> map, Node<K, V>[] tab,
                                int h, K k, V v) {
    Class<?> kc = null;
    boolean searched = false;
    // 找到根節(jié)點
    TreeNode<K, V> root = (parent != null) ? root() : this;
    for (TreeNode<K, V> p = root; ; ) {
        // dir 表示兩個key的比較結(jié)果椎木，ph表示p節(jié)點的hash值
        int dir, ph;
        K pk;
        if ((ph = p.hash) > h)
            // 父節(jié)點的hash值大于新節(jié)點hash值
            dir = -1;
        else if (ph < h)
            // 父節(jié)點的hash值小于新節(jié)點hash值
            dir = 1;
        else if ((pk = p.key) == k || (k != null && k.equals(pk)))
            // 表示key完全相同
            return p;
        else if ((kc == null &&
                // 判斷對key是否實現(xiàn)Comparable接口
                (kc = comparableClassFor(k)) == null) ||
                // 使用Comparable來比較父節(jié)點和新節(jié)點的key值大小
                (dir = compareComparables(kc, k, pk)) == 0) {
            // 這個查找只會執(zhí)行一次
            if (!searched) {
                TreeNode<K, V> q, ch;
                searched = true;
                // 從p的左子樹找到對應(yīng)key的節(jié)點
                if (((ch = p.left) != null &&
                        (q = ch.find(h, k, kc)) != null) ||

                        // 從p的右子樹找到對應(yīng)key的節(jié)點
                        ((ch = p.right) != null &&
                                (q = ch.find(h, k, kc)) != null))

                    //表示key完全相同的節(jié)點
                    return q;
            }
            // 使用默認比較器比較兩個key的大小
            dir = tieBreakOrder(k, pk);
        }

        TreeNode<K, V> xp = p;
        // 自旋找出新節(jié)點的父節(jié)點
        if ((p = (dir <= 0) ? p.left : p.right) == null) {
            Node<K, V> xpn = xp.next;
            TreeNode<K, V> x = map.newTreeNode(h, k, v, xpn);
            // 將新節(jié)點放到對應(yīng)的葉子節(jié)點位置
            if (dir <= 0)
                xp.left = x;
            else
                xp.right = x;
            xp.next = x;
            x.parent = x.prev = xp;
            if (xpn != null)
                ((TreeNode<K, V>) xpn).prev = x;
            // 調(diào)整樹的平衡
            moveRootToFront(tab, balanceInsertion(root, x));
            return null;
        }
    }
}

treeifyBin() 嘗試將鏈表轉(zhuǎn)換成樹的方法

    final void treeifyBin(Node<K, V>[] tab, int hash) {
        int n, index;
        Node<K, V> e;
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            // 檢查數(shù)組長度如果小于64則不進行紅黑樹轉(zhuǎn)換，直接進行擴容
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K, V> hd = null, tl = null;
            do {
                // 將key值對應(yīng)數(shù)組索引位上所有鏈表節(jié)點轉(zhuǎn)換成紅黑樹節(jié)點
                TreeNode<K, V> p = replacementTreeNode(e, null);
                if (tl == null)
                    // 樹的根節(jié)點
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                // 由鏈表轉(zhuǎn)換成了紅黑樹
                hd.treeify(tab);
        }
    }

treeify() 將鏈表轉(zhuǎn)換成紅黑樹

final void treeify(Node<K, V>[] tab) {
    TreeNode<K, V> root = null;
    // for循環(huán)遍歷鏈表所有節(jié)點
    for (TreeNode<K, V> x = this, next; x != null; x = next) {
        // 給下一個節(jié)點賦值
        next = (TreeNode<K, V>) x.next;
        x.left = x.right = null;
        // 給root節(jié)點賦值
        if (root == null) {
            x.parent = null;
            x.red = false;
            root = x;
        } else {
            K k = x.key;
            int h = x.hash;
            Class<?> kc = null;
            for (TreeNode<K, V> p = root; ; ) {
                int dir, ph;
                K pk = p.key;
                // 比較root節(jié)點和X節(jié)點的hash值大小
                if ((ph = p.hash) > h)
                    dir = -1;
                else if (ph < h)
                    dir = 1;
                else if ((kc == null &&
                        (kc = comparableClassFor(k)) == null) ||
                        (dir = compareComparables(kc, k, pk)) == 0)
                    dir = tieBreakOrder(k, pk);
                // 將X節(jié)點添加到紅黑樹
                TreeNode<K, V> xp = p;
                if ((p = (dir <= 0) ? p.left : p.right) == null) {
                    x.parent = xp;
                    if (dir <= 0)
                        xp.left = x;
                    else
                        xp.right = x;
                    // 平衡紅黑樹
                    root = balanceInsertion(root, x);
                    break;
                }
            }
        }
    }
    moveRootToFront(tab, root);
}

resize() 擴容方法

    final Node<K, V>[] resize() {
        // 擴容前的數(shù)組
        Node<K, V>[] oldTab = table;
        // 獲取數(shù)組長度
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        // 擴容閾值
        int oldThr = threshold;
        // 擴容后的數(shù)組長度和擴容閾值
        int newCap, newThr = 0;
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                // 如果數(shù)組容量已經(jīng)大于最大容量（1<<30）了那么將不在進行擴容
                threshold = Integer.MAX_VALUE;
                return oldTab;
            } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                    oldCap >= DEFAULT_INITIAL_CAPACITY)
                // 1. 數(shù)組長度直接擴容2倍
                // 2. 擴容閾值也擴容2倍
                newThr = oldThr << 1; // double threshold
        } else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            // 值為0表示還沒有初始化博烂，然后給數(shù)組初始大小和擴容閾值賦值
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float) newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ?
                    (int) ft : Integer.MAX_VALUE);
        }
        // 擴容閾值賦值
        threshold = newThr;
        @SuppressWarnings({"rawtypes", "unchecked"})
        // 根據(jù)newCap值創(chuàng)建數(shù)組
        Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
        table = newTab;
        // oldTab != null表示是擴容香椎，否則表示是初始化
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K, V> e;
                if ((e = oldTab[j]) != null) {
                    // 將老數(shù)組的對應(yīng)索引位置為NULL，方便GC回收
                    oldTab[j] = null;
                    if (e.next == null)
                        // 如果對應(yīng)索引位（桶）只有一個節(jié)點禽篱，那直接從新計算該節(jié)點的索引位（桶的位置）畜伐，并放到對應(yīng)的位置
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        // 如果原來桶內(nèi)節(jié)點樹樹節(jié)點，那么需要拆分樹
                        ((TreeNode<K, V>) e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        // 和jdk1.7不一樣躺率，這里擴容后鏈表順序不會發(fā)生改變
                        // 低位桶的頭節(jié)點
                        Node<K, V> loHead = null, loTail = null;
                        // 高位節(jié)點高位桶的頭節(jié)點
                        Node<K, V> hiHead = null, hiTail = null;
                        Node<K, V> next;
                        do {
                            // 保存下一個節(jié)點玛界，待下次循環(huán)使用
                            next = e.next;
                            // e.hash & oldCap算法可以算出新的節(jié)點該分配到那個索引位，
                            // 這也是為什么數(shù)組長度一定要是2的n次冪悼吱，否則該算法不可用
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    // 設(shè)置低位桶的頭結(jié)點
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            } else {
                                if (hiTail == null)
                                    // 設(shè)置高位桶的頭結(jié)點
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        // 如果j=0 并且oldCap=16慎框，那么低位桶就是0的索引位，高位桶就是0+16的索引位
                        if (loTail != null) {
                            loTail.next = null;
                            // 設(shè)置低索引位的頭結(jié)點
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            // 設(shè)置高索引位的頭結(jié)點
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

從put方法的源碼我們發(fā)現(xiàn)：

  • HashMap數(shù)組的初始化時在put元素的時候發(fā)生的
  • 發(fā)生擴容條件有兩個：一個是一個桶內(nèi)鏈表數(shù)據(jù)大于8并且數(shù)組長度小于64后添；HashMap總size大于擴容的閾值笨枯。任意滿足一個都會發(fā)生擴容。
  • 在擴容的時候，jdk1.8鏈表的順序?qū)⒉粫侔l(fā)生變化猎醇，從而解決了1.8以前鏈表擴容引發(fā)的死循環(huán)問題。HashMap中是如何形成環(huán)形鏈表可參考這個
  • 數(shù)組長度始終是2的n次冪努溃。這樣做使我們可以直接使用位運算來計算key的索引位硫嘶；在擴容的時候可以直接使用位運算來計算高低位索引的節(jié)點。
  • 鏈表轉(zhuǎn)換成樹的條件是只有當(dāng)一個桶的元素超過8個并且數(shù)組長度大于等于64梧税。
  • 鏈表轉(zhuǎn)換成樹只發(fā)生在一個桶內(nèi)沦疾，也就是說在HashMap的數(shù)據(jù)結(jié)構(gòu)中可以一些桶是鏈表，一些桶是紅黑樹第队。

紅黑樹部分可以參考

get() 方法

    public V get(Object key) {
        Node<K, V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

getNode() 方法

    final Node<K, V> getNode(int hash, Object key) {
        Node<K, V>[] tab;
        Node<K, V> first, e;
        int n;
        K k;
        // 先根據(jù)hash值找到數(shù)據(jù)所在桶內(nèi)的根節(jié)點（頭結(jié)點）
        if ((tab = table) != null && (n = tab.length) > 0 &&
                (first = tab[(n - 1) & hash]) != null) {
            // 如果根節(jié)點（頭結(jié)點）就是我們要找的直接的返回
            if (first.hash == hash && // always check first node
                    ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                // 樹結(jié)構(gòu)的情況
                if (first instanceof TreeNode)
                    return ((TreeNode<K, V>) first).getTreeNode(hash, key);
                // 鏈表結(jié)構(gòu)情況
                do {
                    // 自旋查找
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

tableSizeFor() 方法

我們在初始化HashMap的時候哮塞，我們傳入的初始化大小可能不是2的n次冪。這時我們需要調(diào)用tableSizeFor方法找出和cap最接近的2的n次冪的值凳谦。

    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

HashMap非線程安全的表現(xiàn)

HashMap是一個線程不安全的類忆畅，主要表現(xiàn)在：

  1. 在并發(fā)操作下size的統(tǒng)計會出錯
  2. 并發(fā)操作下添加節(jié)點有可能會丟失數(shù)據(jù)
  3. 在并發(fā)操作下JDK1.7及以前在擴容的時候鏈表有可能會形成環(huán)形數(shù)據(jù)結(jié)構(gòu)，一旦形成環(huán)形數(shù)據(jù)結(jié)構(gòu)尸执，Entry的next節(jié)點永遠不為空家凯，就會產(chǎn)生死循環(huán)獲取Entry。

HashMap空間效率

HashMap其實是一種空間利用率很低的數(shù)據(jù)結(jié)構(gòu)如失，以HashMap<Long绊诲，Long>結(jié)構(gòu)為例，我們具體分析一下HashMap空間效率褪贵。

有效數(shù)據(jù)空間

在HashMap<Long掂之，Long>結(jié)構(gòu)中，只有Key和Value所存放的兩個長整型數(shù)據(jù)是有效數(shù)據(jù)脆丁，共16字節(jié)（2×8字節(jié)）世舰。

實際占用空間

Key和Value這兩個長整型數(shù)據(jù)包裝成java.lang.Long對象之后，就分別具有8字節(jié)的Mark Word槽卫、8字節(jié)的Klass指針冯乘，再加8字節(jié)存儲數(shù)據(jù)的long值。然后這2個Long對象組成Map.Entry之后晒夹，又多了16字節(jié)的對象頭裆馒，然后一個8字節(jié)的next字段和4字節(jié)的int型的hash字段，為了對齊丐怯，還必須添加4字節(jié)的空白填充喷好，最后還有HashMap中對這個Entry的8字節(jié)的引用，這樣增加兩個長整型數(shù)字读跷，實際耗費的內(nèi)存為(Long(24byte)×2)+Entry(32byte)+HashMap Ref(8byte)=88byte梗搅。

空間利用率

空間效率為有效數(shù)據(jù)空間除以實際占用空間，即16字節(jié)/88字節(jié)=18%，這確實太低了无切。

源碼

https://github.com/wyh-spring-ecosystem-student/spring-boot-student/tree/releases

spring-boot-student-concurrent 工程

layering-cache

為監(jiān)控而生的多級緩存框架 layering-cache這是我開源的一個多級緩存框架的實現(xiàn)荡短，如果有興趣可以看一下

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
  • 人面猴
    序言：七十年代末，一起剝皮案震驚了整個濱河市哆键，隨后出現(xiàn)的幾起案子掘托，更是在濱河造成了極大的恐慌，老刑警劉巖籍嘹，帶你破解...
    沈念sama閱讀 221,635評論 6贊 515
  • 死咒
    序言：濱河連續(xù)發(fā)生了三起死亡事件闪盔，死亡現(xiàn)場離奇詭異，居然都是意外死亡辱士，警方通過查閱死者的電腦和手機泪掀，發(fā)現(xiàn)死者居然都...
    沈念sama閱讀 94,543評論 3贊 399
  • 救了他兩次的神仙讓他今天三更去死
    文/潘曉璐 我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來颂碘，“玉大人异赫，你說我怎么就攤上這事⊥凡恚” “怎么了祝辣？”我有些...
    開封第一講書人閱讀 168,083評論 0贊 360
  • 道士緝兇錄：失蹤的賣姜人
    文/不壞的土叔 我叫張陵，是天一觀的道長切油。 經(jīng)常有香客問我蝙斜，道長，這世上最難降的妖魔是什么澎胡？ 我笑而不...
    開封第一講書人閱讀 59,640評論 1贊 296
  • ?港島之戀（遺憾婚禮）
    正文 為了忘掉前任孕荠，我火速辦了婚禮，結(jié)果婚禮上攻谁，老公的妹妹穿的比我還像新娘稚伍。我一直安慰自己，他們只是感情好戚宦，可當(dāng)我...
    茶點故事閱讀 68,640評論 6贊 397
  • 惡毒庶女頂嫁案：這布局不是一般人想出來的
    文/花漫 我一把揭開白布个曙。 她就那樣靜靜地躺著，像睡著了一般受楼。 火紅的嫁衣襯著肌膚如雪垦搬。 梳的紋絲不亂的頭發(fā)上，一...
    開封第一講書人閱讀 52,262評論 1贊 308
  • 城市分裂傳說
    那天艳汽，我揣著相機與錄音猴贰，去河邊找鬼。 笑死河狐，一個胖子當(dāng)著我的面吹牛米绕，可吹牛的內(nèi)容都是我干的瑟捣。 我是一名探鬼主播，決...
    沈念sama閱讀 40,833評論 3贊 421
  • 雙鴛鴦連環(huán)套：你想象不到人心有多黑
    文/蒼蘭香墨 我猛地睜開眼栅干，長吁一口氣：“原來是場噩夢啊……” “哼迈套！你這毒婦竟也來了？” 一聲冷哼從身側(cè)響起碱鳞，我...
    開封第一講書人閱讀 39,736評論 0贊 276
  • 萬榮殺人案實錄
    序言：老撾萬榮一對情侶失蹤桑李，失蹤者是張志新（化名）和其女友劉穎，沒想到半個月后劫笙，有當(dāng)?shù)厝嗽跇淞掷锇l(fā)現(xiàn)了一具尸體芙扎，經(jīng)...
    沈念sama閱讀 46,280評論 1贊 319
  • ?護林員之死
    正文 獨居荒郊野嶺守林人離奇死亡星岗，尸身上長有42處帶血的膿包…… 初始之章·張勛 以下內(nèi)容為張勛視角 年9月15日...
    茶點故事閱讀 38,369評論 3贊 340
  • ?白月光啟示錄
    正文 我和宋清朗相戀三年填大，在試婚紗的時候發(fā)現(xiàn)自己被綠了。 大學(xué)時的朋友給我發(fā)了我未婚夫和他白月光在一起吃飯的照片俏橘。...
    茶點故事閱讀 40,503評論 1贊 352
  • 活死人
    序言：一個原本活蹦亂跳的男人離奇死亡允华，死狀恐怖，靈堂內(nèi)的尸體忽然破棺而出寥掐，到底是詐尸還是另有隱情靴寂，我是刑警寧澤，帶...
    沈念sama閱讀 36,185評論 5贊 350
  • ?日本核電站爆炸內(nèi)幕
    正文 年R本政府宣布召耘，位于F島的核電站百炬，受9級特大地震影響，放射性物質(zhì)發(fā)生泄漏污它。R本人自食惡果不足惜剖踊，卻給世界環(huán)境...
    茶點故事閱讀 41,870評論 3贊 333
  • 男人毒藥：我在死后第九天來索命
    文/蒙蒙 一、第九天 我趴在偏房一處隱蔽的房頂上張望衫贬。 院中可真熱鬧德澈，春花似錦、人聲如沸固惯。這莊子的主人今日做“春日...
    開封第一講書人閱讀 32,340評論 0贊 24
  • 一樁弒父案，背后竟有這般陰謀
    文/蒼蘭香墨 我抬頭看了看天上的太陽葬毫。三九已至镇辉，卻和暖如春，著一層夾襖步出監(jiān)牢的瞬間贴捡，已是汗流浹背摊聋。 一陣腳步聲響...
    開封第一講書人閱讀 33,460評論 1贊 272
  • 情欲美人皮
    我被黑心中介騙來泰國打工， 沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留栈暇，地道東北人麻裁。 一個月前我還...
    沈念sama閱讀 48,909評論 3贊 376
  • 代替公主和親
    正文 我出身青樓，卻偏偏與公主長得像，于是被迫代替她去往敵國和親煎源。 傳聞我的和親對象是個殘疾皇子色迂，可洞房花燭夜當(dāng)晚...
    茶點故事閱讀 45,512評論 2贊 359