HashMap源碼及原理詳解

来源:https://www.cnblogs.com/DehLiu/archive/2022/08/08/16560312.html
-Advertisement-
Play Games

HashMap概要 代碼如果沒有特定說明，為JDK 1.8 HashMap用來存放鍵值對，是Map介面的實現，是非線程安全的 可以存儲key和value為null的值，但key為null的節點只能有一個 哈希值的計算：在hashCode的基礎上添加擾動函數，使元素分佈更加隨機 哈希衝突：通過鏈表存儲 ...


目錄

HashMap概要

代碼如果沒有特定說明，為JDK 1.8

  • HashMap用來存放鍵值對，是Map介面的實現，是非線程安全的
  • 可以存儲key和value為null的值，但key為null的節點只能有一個
  • 哈希值的計算：在hashCode的基礎上添加擾動函數，使元素分佈更加隨機
  • 哈希衝突：通過鏈表存儲具有相同索引的元素，JDK1.8引入紅黑樹解決鏈表過長查詢效率慢的問題
  • 容量：
    • 總是以2的冪次方作為哈希表大小，用於優化key的哈希值的計算過程，預設初始容量為16；
    • 2倍擴容，JDK 1.8優化了key的數組下標的計算過程；JDK 1.8使用尾插法代替頭插法，避免迴圈鏈表問題

JDK1.8 HashMap數據結構圖

image

基本屬性

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
    // 序列號
    private static final long serialVersionUID = 362498820763181265L;
    // 預設的初始容量是16
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
    // 最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30;
    // 預設的填充因數
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    // 當桶(bucket)上的結點數大於這個值時會轉成紅黑樹
    static final int TREEIFY_THRESHOLD = 8;
    // 當桶(bucket)上的結點數小於這個值時樹轉鏈表
    static final int UNTREEIFY_THRESHOLD = 6;
    // 桶中結構轉化為紅黑樹對應的table的最小容量
    static final int MIN_TREEIFY_CAPACITY = 64;
    // 存儲元素的數組，總是2的冪次倍
    transient Node<k,v>[] table;
    // 存放具體元素的集
    transient Set<map.entry<k,v>> entrySet;
    // 存放元素的個數，註意這個不等於數組的長度。
    transient int size;
    // 每次擴容和更改map結構的計數器
    transient int modCount;
    // 臨界值(容量*填充因數) 當實際大小超過臨界值時，會進行擴容
    int threshold;
    // 載入因數
    final float loadFactor;
    //......
}
  • loadFactor：載入因數，用於控制數據存放的密度，預設值為0.75。如果哈希表的數據分佈過於密集，會導致查找效率下降。
  • threshold：HashMap所能容納的最大數據量的Node(鍵值對)個數，當size>threshold（註意這裡是元素的個數，不是數組的長度），執行擴容（resize()）的邏輯。threshold=capacity * loadFactor，

Node節點源碼

// 繼承自 Map.Entry<K,V>
static class Node<K,V> implements Map.Entry<K,V> {
       final int hash;// 哈希值，存放元素到hashmap中時用來與其他元素hash值比較
       final K key;//鍵
       V 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;
        }
        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }
        // 重寫hashCode()方法
        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }
        // 重寫 equals() 方法
        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
}

TreeNode節點源碼

	static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;  // 父
        TreeNode<K,V> left;    // 左
        TreeNode<K,V> right;   // 右
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red;           // 判斷顏色
        TreeNode(int hash, K key, V val, Node<K,V> next) {
            super(hash, key, val, next);
        }
        // 返回根節點
        final TreeNode<K,V> root() {
            for (TreeNode<K,V> r = this, p;;) {
                if ((p = r.parent) == null)
                    return r;
                r = p;
       		}
        }
    	//......
	}

容量初始化

HashMap會保證容量（數組長度）為2的冪次方，預設容量為16。如果創建時，指定了容量，會轉換成就近的、大於等於指定容量的2次冪的容量。如：傳入的容量為10會轉換成16(2^4)。

	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;
    }

容量為2的冪次方的好處

1. 計算key對應的數組下標更加高效

因為&運算比%運算計算的效率更高，源碼中並不是通過key.hashCode()%table.length計算key對應的下標的，而是通過&的方式。

key.hashCode() & (table.length-1)

之所以可以使用&代替%是因為將容量設置為2的冪次方，這樣table.length-1轉換成二進位就能得到高位全部是0，低位全部是1的二進位，用於&運算。如下是table.length=16計算示例：

  10100101 11000100 00100101
& 00000000 00000000 00001111
----------------------------------
  00000000 00000000 00000101    //高位全部歸零，只保留末四位

2. 擴容時更加高效

在哈希表做擴容時，需要重新計算每個節點的哈希值。通過容量為2的冪次方和二倍擴容的機制，可以實現高效的計算哈希值的優化。請查看resize()部分。

哈希的計算

HashMap是通過hashCode去計算數組索引的，從而訪問元素，無論是get()、put()都需要先計算元素對應的哈希值。

另外，為了減少哈希衝突，使節點分佈的更加均勻，HashMap並不是直接使用key.hashCode()作為哈希值，而是添加了擾動函數，把(h = key.hashCode()) ^ (h >>> 16)的計算結果作為哈希值，執行key.hashCode的高16位和低16位的異或運算。

	static final int hash(Object key) {
    	int h;
    	// key.hashCode()：返回散列值也就是hashcode
    	// ^ ：按位異或
   		// >>>:無符號右移，忽略符號位，空位都以0補齊
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
	}

哈希衝突

  • 當發生哈希衝突，使用鏈表把具有相同數組索引串在一起。

  • 如果鏈表長度大於閾值（預設為8），且哈希表的數組長度大於或等於64時，會轉換成紅黑樹，減少搜索時間；否則，執行resize()對數組擴容。

put - 添加元素

image

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

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // table未初始化或者長度為0，進行擴容
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // (n - 1) & hash 確定元素存放在哪個桶中，桶為空，新生成結點放入桶中(此時，這個結點是放在數組中)
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    // 桶中已經存在元素
    else {
        Node<K,V> e; K k;
        // 比較桶中第一個元素(數組中的結點)的hash值相等，key相等
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
                // 將第一個元素賦值給e，用e來記錄
                e = p;
        // hash值不相等，即key不相等；為紅黑樹結點
        else if (p instanceof TreeNode)
            // 放入樹中
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        // 為鏈表結點
        else {
            // 在鏈表最末插入結點
            for (int binCount = 0; ; ++binCount) {
                // 到達鏈表的尾部
                if ((e = p.next) == null) {
                    // 在尾部插入新結點
                    p.next = newNode(hash, key, value, null);
                    // 結點數量達到閾值(預設為 8 )，執行 treeifyBin 方法
                    // 這個方法會根據 HashMap 數組來決定是否轉換為紅黑樹。
                    // 只有當數組長度大於或者等於 64 的情況下，才會執行轉換紅黑樹操作，以減少搜索時間。否則，就是只是對數組擴容。
                    if (binCount >= TREEIFY_THRESHOLD - 1) // 減1，是因為頭節點要計算在內，所以鏈表長度需要達到TREEIFY_THRESHOLD，才會調用treeifyBin
                        treeifyBin(tab, hash);
                    // 跳出迴圈
                    break;
                }
                // 判斷鏈表中結點的key值與插入的元素的key值是否相等
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    // 相等，跳出迴圈
                    break;
                // 用於遍歷桶中的鏈表，與前面的e = p.next組合，可以遍歷鏈表
                p = e;
            }
        }
        // 表示在桶中找到key值、hash值與插入元素相等的結點
        if (e != null) {
            // 記錄e的value
            V oldValue = e.value;
            // onlyIfAbsent為false或者舊值為null
            if (!onlyIfAbsent || oldValue == null)
                //用新值替換舊值
                e.value = value;
            // 訪問後回調
            afterNodeAccess(e);
            // 返回舊值
            return oldValue;
        }
    }
    // 結構性修改
    ++modCount;
    // 實際大小大於閾值則擴容
    if (++size > threshold)
        resize();
    // 插入後回調
    afterNodeInsertion(evict);
    return null;
}

說明：

  • 在訪問元素的過程中，先比較key.hashCode，如果hashCode不相等，就直接跳過；否則，再調用key.equals()比較元素。這麼做的好處是hashCode的比較效率要高於調用equals()。
  • JDK 1.8在鏈表的基礎上添加了紅黑樹，當數組長度>=64，且鏈表長度>=8時，就會將鏈表轉換成紅黑樹。
  • 擴容的觸發條件：
    • 元素個數大於>threshold
    • 數組為空
    • treeifyBin()方法中，數組長度<64

get - 獲取元素

public V get(Object key) {
    Node<K,V> e;
    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;
    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;
        // 桶中不止一個節點
        if ((e = first.next) != null) {
            // 在樹中get
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            // 在鏈表中get
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

  1. 通過hash計算數組下標

  2. 查找元素：

    2.1 頭節點命中，直接返回

    2.2 在紅黑樹中查找，返回查找結果

    2.3 在鏈表中查找，命中返回

命中：hash值相等，且key相等

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;
    if (oldCap > 0) {
        // 超過整數最大值就不再擴充
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 沒超過最大值，就擴充為原來的2倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {
        // signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 計算新的resize上限
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    
    //創建新的數組
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    
    table = newTab;
    if (oldTab != null) {
        // 把每個bucket都移動到新的buckets中
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            //對不為空的bucket執行遷移
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null; 
                //bucket中僅有一個節點，直接遷移（這裡不會發生哈希衝突嗎？）
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    //樹節點的遷移
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else {
                    //鏈表的節點遷移
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;//用於保存原數組中鏈表的下一個節點
                    do {
                        next = e.next;
                        // 新的索引=原索引
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        // 新的索引=原索引+oldCap
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // 原索引放到bucket里
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    // 原索引+oldCap放到bucket里
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

可以看到擴容的方式，並不會改變節點原先在鏈表中的順序，即尾插法。

JDK 1.8優化了key的哈希計算過程

JDK 1.8的resize()優化了key的哈希計算過程。

優化的前提：

  1. 哈希表的長度為2的冪次方
  2. 哈希表的擴容為2倍擴容

HashMap擴容後，newCap=2*oldCap，那麼key.hash & (newCap -1)計算新的下標時，mask會在高位多個1。而key在這個位置的值不是0就是1，如果是0，那麼新的數組下標=原來數組下標；如果是1，那麼新的數組下標=原數組下標+oldCap。

image
image

JDK 1.8的尾插的優化，解決環形鏈表問題

JDK 1.8擴容時，使用尾插代替JDK 1.7的頭插法，不會改變節點原有的順序，避免了多線程下環形鏈表的問題。

JDK 1.7頭插法擴容和環形鏈表問題

以下為JDK 1.7的擴容源碼

 1 void resize(int newCapacity) {   //傳入新的容量
 2     Entry[] oldTable = table;    //引用擴容前的Entry數組
 3     int oldCapacity = oldTable.length;         
 4     if (oldCapacity == MAXIMUM_CAPACITY) {  //擴容前的數組大小如果已經達到最大(2^30)了
 5         threshold = Integer.MAX_VALUE; //修改閾值為int的最大值(2^31-1)，這樣以後就不會擴容了
 6         return;
 7     }
 8  
 9     Entry[] newTable = new Entry[newCapacity];  //初始化一個新的Entry數組
10     transfer(newTable);                         //！！將數據轉移到新的Entry數組裡
11     table = newTable;                           //HashMap的table屬性引用新的Entry數組
12     threshold = (int)(newCapacity * loadFactor);//修改閾值
13 }

 1 void transfer(Entry[] newTable) {
 2     Entry[] src = table;                   //src引用了舊的Entry數組
 3     int newCapacity = newTable.length;
 4     for (int j = 0; j < src.length; j++) { //遍歷舊的Entry數組
 5         Entry<K,V> e = src[j];             //取得舊Entry數組的每個元素
 6         if (e != null) {
 7             src[j] = null;//釋放舊Entry數組的對象引用（for迴圈後，舊的Entry數組不再引用任何對象）
 8             do {
 9                 Entry<K,V> next = e.next;
10                 int i = indexFor(e.hash, newCapacity); //重新計算每個元素在數組中的位置
11                 e.next = newTable[i]; //這裡要插入的節點的下一個節點直接設置成了當前鏈表的頭節點
12                 newTable[i] = e;      //將元素放在數組上
13                 e = next;             //訪問下一個Entry鏈上的元素
14             } while (e != null);
15         }
16     }
17 }

transfer()的11和12行代碼展示了頭插的方式，即原鏈表在擴容之後，被反轉了。（可以打個斷點演示一下這個過程就清楚了。）

容量為2的HashMap擴容示例

image

可以看到鏈表反轉了，即原先是{5,9}的順序，擴容後，順序變為{9,5}。

迴圈鏈表問題

在多個線程同時擴容時，頭插法可能形成環形鏈表，造成死迴圈。具體實例可以參考Java 8系列之重新認識HashMap

參考：


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • MYSQL的Java操作器——JDBC
    MYSQL的Java操作器——JDBC 在學習了Mysql之後，我們就要把Mysql和我們之前所學習的Java所結合起來 而JDBC就是這樣一種工具：幫助我們使用Java語言來操作Mysql資料庫 JDBC簡介 首先我們先來瞭解一下JDBC JDBC概念： JDBC是使用Java語言操作關係資料庫的 ...
  • 我說MySQL聯合索引遵循最左首碼匹配原則，面試官讓我回去等通知
    面試官：我看你的簡歷上寫著精通MySQL，問你個簡單的問題，MySQL聯合索引有什麼特性？ 我：MySQL聯合索引遵循最左首碼匹配原則，即最左優先，查詢的時候會優先匹配最左邊的索引。 例如當我們在(a,b,c)三個欄位上創建聯合索引時，實際上是創建了三個索引，分別是(a)、(a,b)、(a,b,c)... ...
  • 有趣的特性：CHECK約束
    有趣的特性：CHECK約束 功能說明 在MySQL 8.0.16以前， CREATE TABLE允許從語法層面輸入下列CHECK約束，但實際沒有效果： CHECK (expr) 在 MySQL 8.0.16，CREATE TABLE添加了針對所有存儲引擎的表和列的CHECK約束的核心特性。CREAT ...
  • Antdv+Asp.net WebApi開發學生信息管理系統（一）
    在B/S系統開發中，前後端分離開發設計已成為一種標準，而VUE作為前端三大主流框架之一，越來越受到大家的青睞，Antdv是Antd在Vue中的實現。本系列文章主要通過Antdv和Asp.net WebApi開發學生信息管理系統，簡述前後端分離開發的主要相關內容，僅供學習分享使用，如有不足之處，還請指... ...
  • vue3的管理端項目工程模板來了~~可直接快速開發項目，不用再考慮各種配置和優化~
    vue3-admin-template 項目地址：vue3-admin-template 能拿來直接開發項目，不需要考慮格式化配置、打包編譯優化等等，難道它不香嗎？~~ 此項目是集成vue3 + vite + Element-Plus + Pinia + vue-router的後臺管理系統的模板工程 ...
  • Vue3系列8--全局組件，局部組件，遞歸組件
    1 配置全局組件 當一個組件使用頻率非常高的時候，可以考慮設置其為全局組件，方便其他地方調用。 案例 我這兒封裝一個Card組件想在任何地方去使用： <template> <div class="card"> <div class="card-header"> <div>主標題</div> <div ...
  • canvas實現圖片標記
    前言 由於業務需求，需要有一個圖片標記功能，其實就是對圖片畫框畫線做標記，類似微信的圖片編輯 但是需要存下標記圖及其標記的具體數據,。功能其實很簡單，但剛開始的時候也是費了一些功夫的。我將原項目中該功能抽離出來單獨寫了一個demo，作為記錄，同時你們在開發過程中有類似需求的話也可以參考一下該思路，其 ...
  • 20 多個好用的 Vue 組件庫
    原文鏈接：20 多個好用的 Vue 組件庫 在本文中，將分享一些常見的 vue.js 組件。 Tables / Data Grids Vue Tables-2 地址：https://github.com/matfish2/vue-tables-2 Vue Tables 2 旨在為開發者提供一個功能齊 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類