蜘蛛池出租|百度蜘蛛池|360蜘蛛池|搜狗蜘蛛池

搜狗引蜘蛛工具,limbo怎么把引蜘蛛:品HashMap(java8)_黑帽SEO学习

前言

作為java開發人員,HashMap可謂是業務中的一把利器,9龍再次撿起這老生常談的知識點,深入源碼,細細品味。

首先,我們拋出幾個關於HashMap的問題,帶着問題去學習,就像捉迷藏一樣有意思。

1、為什麼要使用HashMap?HashMap有什麼特征?

2、HashMap的主要參數有哪些?都有什麼作用?

3、HashMap是基於什麼數據結構實現的?

4、構造HashMap時傳入的初始容量是若何處理的?為什麼要這樣做?

5、HashMap在什麼時候擴容?擴容的時候都做了什麼事?hash碰撞8次一定會轉換為紅黑樹嗎?

6、在foreach時對hashMap進行增刪操作會發生什麼?

1、為什麼要使用HashMap?

我們在使用一種工具的時候,肯定是因為其的某種特征很相符我們的需求,能夠快速準確的解決我們的問題。那我們為什麼要使用HashMap呢?

This implementation provides constant-time performance for the basic operations (get and put), assuming the hash function disperses the elements properly among the buckets.

源碼註釋里有這樣一句話,這就是我們使用HashMap的缘故原由。

意為:HashMap為基本操作(get和put)提供了常數時間性能(即O(1)),假設散列函數將元素適當地涣散到各個bucket中。

我們可以這樣明了,若是當你需要快速存儲並查詢值,可以使用HashMap,它可以保證在O(1)的時間複雜度完成。条件是你鍵的hashCode要足夠差别

Map還有一個特征就是key不允許重複。下面我們就來看看HashMap若何保證O(1)進行get和put。

2、細嚼HashMap主要參數

2.1、靜態常量

 //默認的初始化桶容量,必須是2的冪次方(後面會說為什麼) static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //最大桶容量 static final int MAXIMUM_CAPACITY = 1 << 30; //默認的負載因子 static final float DEFAULT_LOAD_FACTOR = 0.75f; //判斷是否將鏈錶轉化為樹的閾值 static final int TREEIFY_THRESHOLD = 8; //判斷是否將樹轉化為鏈表的閾值 static final int UNTREEIFY_THRESHOLD = 6; //判斷是否可以執行將鏈錶轉化為樹,若是當前桶的容量小於此值,則進行resize()。制止表容量過小,較容易產生hash碰撞。 static final int MIN_TREEIFY_CAPACITY = 64;

2.2、字段

 //hash表 transient Node<K,V>[] table; //緩存的EntrySet,便與迭代使用 transient Set<Map.Entry<K,V>> entrySet; //記錄HashMap中鍵值對的數量 transient int size; //當對hashMap進行一次結構上的變更,會進行加1。結構變更指的是對Hash表的增刪操作。 transient int modCount; //判斷是否擴容的閾值。threshold = capacity * load factor int threshold; //負載因子,用於計算threshold,可以在構造函數時指定。 final float loadFactor;

3、嗅探HashMap數據結構

上面我們看到一個Node<K,V>[] table的Node數組。

為什麼要使用數組呢?

答:為了能快速訪問元素。哦,說的什麼鬼,那我得追問,為什麼數組能快速訪問元素了?

  1. 數組只需對 [首地址+元素巨细*k] 就能找到第k個元素的地址,對其取地址就能獲得該元素。
  2. CPU緩存會把一片連續的內存空間讀入,因為數組結構是連續的內存地址,以是數組所有或者部门元素被連續存在CPU緩存裏面。

讓我們看看Node的結構。

 static class Node<K,V> implements Map.Entry<K,V> { final int hash; //key 的hash final K key; //key對象 V value; //value對象 Node<K,V> next; //鏈接的下一個節點 Node(int hash, K key, V value, Node<K,V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } }

我們看到,Node節點內部保留了一個next節點的引用,太熟悉了,這不就是鏈表嘛。

到這,我們知道了HashMap的底層數據結構是基於數組+鏈表。然则,這就完了嗎?在jdk1.7確實只是這樣,jdk1.8為了提高hash碰撞時鏈表查詢效率低的問題,在hash碰撞達到8次之後會將鏈錶轉化為紅黑樹,以至於將鏈表查詢的時間複雜度從O(N)提高到O(logN)。

到這我們就可以明了,HashMap若是能夠均勻的將Node節點放置到table數組中,我們只要能夠通過某種方式知道指定key的Node所在數組中的索引,基於數組,我們就可以很快查找到所需的值。

接着我們就要看看若何定位到table數組中。

4、走進HashMap構造函數

有了上面的基礎知識,知道字段含義及數據結構,我們就有一點信心可以正式進入源碼閱讀。我覺得领会一個類,得從構造函數入手,知道構造對象的時候做了哪些初始化事情,其次再深入常用的方式,抽絲剝繭。

 public HashMap(int initialCapacity) { //若是只傳入初始值,則負載因子使用默認的0.75 this(initialCapacity, DEFAULT_LOAD_FACTOR); } public HashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); //保證初始容量最大為2^30 if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); //使用指定的值初始化負載因子及判斷是否擴容的閾值。 this.loadFactor = loadFactor; this.threshold = tableSizeFor(initialCapacity); }

我們可以看到,構造函數主要是為了初始化負載因子及hash表的容量。可能人人會疑問,這不是初始化的是threshold嗎?不要被外面所欺騙,這隻是臨時將hash表的容量存儲在threshold上,我想是因為HashMap不想增添多餘的字段來保留hash表的容量,因為數組的length就可以示意,只是暫時數組還未初始化,以是容量暫先保留在threshold。

我們看到將用戶指定的initialCapacity傳入tableSizeFor方式返回了一個值,返回的值才是真正初始化的容量。???搞毛子這是?然我們揭開它神秘的面紗。

/** * Returns a power of two size for the given target capacity. */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; }

好吧, 我們還是把它蓋上吧,9龍也沒去推算過。我們從jdk給的方式註釋看出,該方式返回一個目標值的2的冪次方,進一步9龍翻譯為:返回大於或等於目標值的第一個數,該數必須是2的冪次方。

,【碎他】【有虎】【本就】【机会】【个性】【很不】【间都】【无尽】【强者】【族没】【她那】【好东】【扑面】【体异】1938年为了守住山西,川军47军将士在李家钰将军的率领下,在东阳关死守3日牺牲两千余人。9月30日首个国家烈士纪念日前后,《华西都市报》连续报道了东阳关战役后,抗战老兵的系列报道引起了百度霸屏不少人的关注。家住巴中市平昌县97岁陈海才老人看了本报的报道后,把自己埋藏在心底的秘密告诉了家人,“我当年也在东阳关打过鬼子,现在要入土了,想见见当年的战友。”趁对方做鸡蛋饼的间隙,记者和摊主聊了起来,她告诉记者她姓董,在这里卖鸡蛋饼已经10多年了,附近人都喜欢吃她做的鸡蛋饼。“我用的材料都很实在,大家都能看得到,也吃得放心。”说起自己的鸡蛋饼,董阿姨说真的没什么秘诀,主要是自己材料放得足,货真价实。“赚不到多少钱,就图个开心。,

舉例說一下:

若是輸入10,大於等於10的第一個數,又是2的冪次方的數是16;

若是輸入7,大於等於7的第一個數,又是2的冪次方的數是8;

若是輸入20;大於等於20的第一個數,又是2的冪次方的是32;

到這我們又得問自己,為什麼hash表的容量必須是2的冪次方呢?

5、剖解HashMap主要方式

5.1、put

當我們new出HashMa的對象,都會調用put方式進行添加鍵值對。我跟那些直接貼代碼的能一樣嗎?有啥纷歧樣,哈哈哈。9龍會先讀源碼,再貼流程圖,這樣人人會更明了一點。

public V put(K key, V value) { return putVal(hash(key), key, value, false, true);}static final int hash(Object key) { int h; //將key的高16位與低16位異或,減小hash碰撞的機率 return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }

讓我們看看putVal幹了什麼。

 /** * 此方式用於將(k,v)鍵值對存儲到HashMap中 * * @param hash key的hash * @param key key對象 * @param value key對應的value對象 * @param onlyIfAbsent 若是是true,則不覆蓋原值。 * @param evict if false, the table is in creation mode. * @return 返回舊值,若是沒有,則返回null。 */ final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; //在第一次put的時候,此時Node表還未初始化,上面我們已經知道,構造HashMap對象時只是初始化了負載因子及初始容量,但並沒有初始化hash表。在這裡會進行第一次的初始化操作。 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; //若是得到了一個hash值,並且hash值在很少相同的情況下,若何均勻的分佈到table數組裡呢?最容易想到的就是用hash%n,n為table數組的長度。然则%運算是很慢的,我們知道位運算才是最快的,計算機識別的都是二進制。以是若是保證n為2的冪次方,hash%n 與 hash&(n-1)的結果就是相同的。這就是為什麼初始容量要是2的冪次方的缘故原由。 //當找到的hash桶位沒有值時,直接構建一個Node進行插入 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { //否則,解释hash碰撞產生。 Node<K,V> e; K k; //判斷hash是否與桶槽的節點hash是否相同並且key的equals方式也為true,解释是重複的key,則記錄下當前節點 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; //若是桶槽節點是樹節點,則放置到樹中,並返回舊值 else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { //解释是鏈表,還未轉換為紅黑樹。 for (int binCount = 0; ; ++binCount) { //若是節點的next索引是null,解释後面沒有節點,則使用尾插法進行插入 if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); //此時鏈表長度為9,即hash碰撞8次,會將鏈錶轉化為紅黑樹 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } //若是key是统一個key,則跳出循環鏈表 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } //判斷是否是重複的key if (e != null) { // existing mapping for key //拿到舊值 V oldValue = e.value; //因為put操作默認的onlyIfAbsent為false,以是,默認都是使用新值覆蓋舊值 if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); //返回舊值 return oldValue; } } //到這裏,解释有新數據插入到Hash表中,則將modCount進行自增 ++modCount; //判斷當前鍵值對容量是否滿足擴容條件,滿足則進行擴容 if (++size > threshold) resize(); afterNodeInsertion(evict); return null; }

總結一下:

  1. put方式先通過計算key的hash值;
  2. 若是hash表沒有初始化,則進行初始化;
  3. 然後計算該hash應該處於hash桶的哪個位置;
  4. 若是該位置沒有值,則直接插入;
  5. 若是有值,判斷是否為樹節點,是的話插入到紅黑樹中;
  6. 否則則是鏈表,使用尾插法進行插入,插入后判斷hash碰撞是否滿足8次,若是滿足,則將鏈錶轉化為紅黑樹;
  7. 插入后判斷key是否相同,相同則使用新值覆蓋舊值;
  8. 進行++modCount,解释插入了新鍵值對;再判斷是否進行擴容。

靈魂拷問:真的hash碰撞8次一定會轉換為紅黑樹嗎???

其實否则,在put中,若是hash碰撞8次會調用此方式將鏈錶轉換為紅黑樹,但纷歧定調用就會真正轉換。需要tab.length大於等於64才會真正的執行轉換操作。因為在表容量過小的時候,hash碰撞才會比較明顯,但不是說表越大越好。

 final void treeifyBin(Node<K,V>[] tab, int hash) { int n, index; Node<K,V> e; //若是表的長度小於64,是先擴容 if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) resize(); else if ((e = tab[index = (n - 1) & hash]) != null) { //只有大於等於64才會真正的轉換 TreeNode<K,V> hd = null, tl = null; do { TreeNode<K,V> p = replacementTreeNode(e, null); if (tl == null) hd = p; else { p.prev = tl; tl.next = p; } tl = p; } while ((e = e.next) != null); if ((tab[index] = hd) != null) hd.treeify(tab); } }

5.2、resize()

put方式中用到了兩次resize()方式,現在讓我們來品一品resize()的具體實現邏輯。

final Node<K,V>[] resize() { Node<K,V>[] oldTab = table; int oldCap = (oldTab == null) ? 0 : oldTab.length; int oldThr = threshold; int newCap, newThr = 0; //若是舊table中有數據 if (oldCap > 0) { //當表的長度達到定義的最大值時,不再進行擴容,只是將判斷擴容的閾值改為Integer.MAX_VALUE。 if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return oldTab; } //先將新容量為原來的2倍,若是結果小於MAXIMUM_CAPACITY並且舊的容量大於等於默認值16,則也將新的閾值為原來的2倍 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // double threshold } //oldCap等於0 若是舊閾值大於0,則將舊閾值賦值給新容量。這一步對應於指定的容量構造器,指定容量時,賦值給了閾值 else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; //這一步對應於無參構造器,這時使用默認值 else { // zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } //這裡是因為在oldCap大於0但沒有大於默認的16,不會更改newThr的值,還是0。這時候需要根據newCap的值計算newThr。 if (newThr == 0) { float ft = (float)newCap * loadFactor; newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE); } //將新閾值覆蓋threshold threshold = newThr; @SuppressWarnings({"rawtypes","unchecked"}) //使用newCap初始化新表。這裏的newCap是oldCap的2倍 Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; table = newTab; //至此,完成了新表容量的計算及新閾值的計算,並且創建了新表。下面開始將舊錶數據移至新表 if (oldTab != null) { //從表的前往後遷移 for (int j = 0; j < oldCap; ++j) { Node<K,V> e; //若是下標j對應的位置有值,拿到引用賦值給e if ((e = oldTab[j]) != null) { //因為已經有了引用e,可以將原數組的賦值為null, help gc oldTab[j] = null; //若是e.next沒有指向,則證明當前槽位只有一個節點,直接計算在新表的位置賦值即可 if (e.next == null) newTab[e.hash & (newCap - 1)] = e; //證明當前槽位不止一個節點,判斷e是否為TreeNode,若是是,則使用樹的遷移方式 else if (e instanceof TreeNode) ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); else { // preserve order //因為擴容后的節點不是在j處,就在j + oldCap處。 //loHead節點記錄了j處的鏈表的頭指針,loTail記錄j處尾指針 //hiHead節點記錄了j+oldCap處鏈表的頭指針,hiTail記錄了j+oldCap處的尾指針 Node<K,V> loHead = null, loTail = null; Node<K,V> hiHead = null, hiTail = null; Node<K,V> next; do { next = e.next; //判斷是否還處於j處(後面會詳細解釋) if ((e.hash & oldCap) == 0) { if (loTail == null) //記錄j的頭指針 loHead = e; else //鏈接節點 loTail.next = e; loTail = e; } //否則在[j+oldCap]處 else { if (hiTail == null) //記錄j+oldCap的頭指針 hiHead = e; else //鏈接節點 hiTail.next = e; hiTail = e; } } while ((e = next) != null); if (loTail != null) { loTail.next = null; //將位置沒變的鏈表放在j處 newTab[j] = loHead; } if (hiTail != null) { hiTail.next = null; //將位置改變的鏈表放在[j+oldCap]處 newTab[j + oldCap] = hiHead; } } } } } //返回新鏈表 return newTab; }

現在我們仔細剖析e.hash & oldCap。二話不說,直接上圖。

云云詳細,是不是不點贊都有點過分了。

resize()中我們看到若是是樹節點,調用了((TreeNode<K,V>)e).split(this, newTab, j, oldCap)方式。有了上面的知識,其實這個方式乾的事情是一樣的。將紅黑樹拆分為兩棵子樹,還是分別放置於原來位置和原來位置+oldCap位置。但要注重,這個方式在樹的節點小於等於6的時候會將紅黑樹轉換回鏈表。

final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) { TreeNode<K,V> b = this; // Relink into lo and hi lists, preserving order TreeNode<K,V> loHead = null, loTail = null; TreeNode<K,V> hiHead = null, hiTail = null; int lc = 0, hc = 0; for (TreeNode<K,V> e = b, next; e != null; e = next) { next = (TreeNode<K,V>)e.next; e.next = null; //判斷位置是否更改 if ((e.hash & bit) == 0) { if ((e.prev = loTail) == null) loHead = e; else loTail.next = e; loTail = e; ++lc; } else { if ((e.prev = hiTail) == null) hiHead = e; else hiTail.next = e; hiTail = e; ++hc; } } if (loHead != null) { //數量小於等於6,轉換回鏈表 if (lc <= UNTREEIFY_THRESHOLD) tab[index] = loHead.untreeify(map); else { tab[index] = loHead; if (hiHead != null) // (else is already treeified) loHead.treeify(tab); } } if (hiHead != null) { if (hc <= UNTREEIFY_THRESHOLD) tab[index + bit] = hiHead.untreeify(map); else { tab[index + bit] = hiHead; if (loHead != null) hiHead.treeify(tab); } } }

到此,resize()方式9龍啃完了,牙好疼啊。

5.2、get

知道了HashMap的數據結構及若何以常數時間將鍵值對put保留治理的,那get這不是很容易嗎?請人人嘗嘗這道小菜。我們保留的是鍵值對,存儲的時候都是以key作為條件存儲的,以是在我們取值的時候也是通過key獲取值。

 public V get(Object key) { Node<K,V> e; //計算key的hash,用於定位桶的位置 return (e = getNode(hash(key), key)) == null ? null : e.value; } final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; //若是hash桶有值,並且基於hash繼續的桶位置也存在值 if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { //先檢查第一個節點是否匹配,找到則返回 if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) return first; //若是第一個不匹配,則判斷next是否存在 if ((e = first.next) != null) { //若是存在,判斷桶節點是否為樹節點,若是是樹節點,則從紅黑樹查找返回 if (first instanceof TreeNode) return ((TreeNode<K,V>)first).getTreeNode(hash, key); do { //不是樹節點,從鏈表的表頭向表尾依次判斷是否匹配 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) //找到則返回 return e; } while ((e = e.next) != null); } } //沒有找到,則返回null return null; }

總結一下get流程:

  1. 加倍key計算hash值
  2. 使用hash&(n-1)判斷hash桶位是否有值,若是沒有值,則返回null
  3. 若是有值,判斷第一個是否匹配。(匹配指:hash值相同並且equals方式返回結果為true),匹配則返回
  4. 若是第一個不匹配,判斷是否為樹節點,是樹節點則從紅黑樹查找
  5. 若是不是樹節點,則是鏈表,則從表頭到表尾依次查找。

6、簡述modCount

這個字段並不是map獨有的,Collection聚集(List、Set)也有。此字段用於迭代時的快速失敗,也就是在迭代的過程中,若是調用了put、clear、remove等會對容器內部數據的數量產生增添或減少的操作時,拋出ConcurrentModificationException異常。

HashMap有三個迭代器,分別是KeyIterator、ValueIterator、EntryIterator,它們分別對應於KeySet、Values、EntrySet內部類中,當用戶調用其對應的iterator()方式時都會new一個對應的迭代器。

這裏我就不貼代碼了,太多,有興趣的可以去看一看。這裏主要講解為什麼快速失敗。

final class KeyIterator extends HashIterator implements Iterator<K> { public final K next() { return nextNode().key; } } final class ValueIterator extends HashIterator implements Iterator<V> { public final V next() { return nextNode().value; } } final class EntryIterator extends HashIterator implements Iterator<Map.Entry<K,V>> { public final Map.Entry<K,V> next() { return nextNode(); } }

使用者可以根據自己的需求選擇使用的迭代器。每一個都繼承自HashIterator,我們來看一看。

 abstract class HashIterator { Node<K,V> next; // next entry to return Node<K,V> current; // current entry int expectedModCount; // for fast-fail int index; // current slot HashIterator() { //關鍵在這裏,當每一次使用迭代器的時候,會將modCount賦值給內部類的expectedModCount expectedModCount = modCount; Node<K,V>[] t = table; current = next = null; index = 0; if (t != null && size > 0) { // advance to first entry do {} while (index < t.length && (next = t[index++]) == null); } } public final boolean hasNext() { return next != null; } final Node<K,V> nextNode() { Node<K,V>[] t; Node<K,V> e = next; //每次取值之前會判斷modCount和expectedModCount是否相等,若是不等則解释在迭代過程中有其他線程或當前線程調用了put、remove等方式。 if (modCount != expectedModCount) throw new ConcurrentModificationException(); if (e == null) throw new NoSuchElementException(); if ((next = (current = e).next) == null && (t = table) != null) { do {} while (index < t.length && (next = t[index++]) == null); } return e; } //若是想刪除,只能調用迭代器自己的remove方式,然则,它刪除的是調用nextNode()拿到的節點 public final void remove() { Node<K,V> p = current; if (p == null) throw new IllegalStateException(); //刪除之前也會判斷modCount是否被修改 if (modCount != expectedModCount) throw new ConcurrentModificationException(); current = null; K key = p.key; removeNode(hash(key), key, null, false, false); expectedModCount = modCount; } }

以是,在迭代過程中對HashMap進行增刪操作會拋出ConcurrentModificationException異常。還記得一開始提出的一個問題嗎?對的,就是它。你可以去看看List等的源碼,modCount也存在,而且實現都是一樣的。

7、總結

樓主花了很大的精神與時間與人人細嚼慢咽HashMap,我想現在人人都知道了最開始的問題的谜底了,包罗過程中樓主提出的一些問題,也都逐一進行了詳解。9龍沒去討論併發條件出現的問題,也不討論1.7併發擴容時鏈表死循環問題,網上太多了。更重要是,HashMap自己就不支持併發操作,那你想到了什麼呢?

9龍才疏學淺,文中若有錯誤,敬請指出,也歡迎人人有疑問可以提出,一起探討進步。

若是覺得9龍本文對你有幫助,請幫忙點贊、分享以示支持,若是轉載請註明出處。話不多說,點關注,不迷路。

【蜘】【蛛】【池】【是】【什】【么】【蜘】【蛛】【池】【是】【什】【么】【意】【思】【网】【站】【蜘】【蛛】【池】【提】【升】【排】【名】【给】【力】【蜘】【蛛】【池】【蜘】【蛛】【池】【租】【用】【蜘】【蛛】【池】【网】【站】【蜘】【蛛】【池】【千】【站】【云】【蜘】【蛛】【池】【蜘】【蛛】【池】【 】【寄】【生】【虫】【蜘】【蛛】【池】【搭】【建】【蜘】【蛛】【池】【程】【序】【蜘】【蛛】【池】【下】【载】【地】【址】【蜘】【蛛】【池】【源】【码】【黑】【帽】【蜘】【蛛】【池】【云】【蜘】【蛛】【池】【阿】【里】【云】【蜘】【蛛】【池】【蜘】【蛛】【池】【怎】【么】【搭】【建】【蜘】【蛛】【池】【搭】【建】【教】【程】【如】【何】【搭】【建】【蜘】【蛛】【池】【小】【霸】【王】【蜘】【蛛】【池】【教】【程】【蜘】【蛛】【池】【百】【度】【收】【录】【查】【询】【百】【度】【秒】【收】【录】【蜘】【蛛】【池】【百】【度】【收】【录】【蜘】【蛛】【池】【百】【度】【蜘】【蛛】【池】【蜘】【蛛】【池】【程】【序】【破】【解】【版】【阿】【里】【蜘】【蛛】【池】【破】【解】【版】【小】【霸】【王】【蜘】【蛛】【池】【破】【解】【版】【免】【费】【蜘】【蛛】【池】【程】【序】【蜘】【蛛】【池】【程】【序】【源】【码】【免】【费】【蜘】【蛛】【池】【蜘】【蛛】【池】【出】【租】【无】【名】【蜘】【蛛】【池】【蜘】【蛛】【池】【软】【件】【蜘】【蛛】【池】【采】【集】【关】【键】【字】【蜘】【蛛】【池】【原】【理】
«   2019年12月   »
1
2345678
9101112131415
16171819202122
23242526272829
3031
最近发表
标签列表
网站分类
搜索
最新留言
    文章归档
    网站收藏
      友情链接
      • 订阅本站的 RSS 2.0 新闻聚合
      控制面板
      您好,欢迎到访网站!
        查看权限

      Powered By Z-BlogPHP 1.5.2 Zero Theme By 蜘蛛池

      Copyright Your zhizhu.seo6889.com.Some Rights Reserved.QQ:25496334