圖解AQS的設計與實現，手摸手帶你實現一把互斥鎖！

来源:https://www.cnblogs.com/liqiangchn/archive/2019/11/29/11960944.html
-Advertisement-
Play Games

AQS是併發編程中非常重要的概念，它是juc包下的許多併發工具類，如CountdownLatch，CyclicBarrier，Semaphore 和鎖, 如ReentrantLock， ReaderWriterLock的實現基礎，提供了一個基於int狀態碼和隊列來實現的併發框架。本文將對AQS框架的 ...


AQS是併發編程中非常重要的概念，它是juc包下的許多併發工具類，如CountdownLatch，CyclicBarrier，Semaphore 和鎖, 如ReentrantLock， ReaderWriterLock的實現基礎，提供了一個基於int狀態碼和隊列來實現的併發框架。本文將對AQS框架的幾個重要組成進行簡要介紹，讀完本文你將get到以下幾個點：

  1. AQS進行併發控制的機制是什麼
  2. 共用模式和獨占模式獲取和釋放同步狀態的詳細過程
  3. 基於AQS框架實現一個簡易的互斥鎖

一，AQS基本概念

AQS（AbstractQueuedSynchronizer）是用來構建鎖或者其他同步組件的基礎框架，它使用了一個int成員變數來表示狀態，通過內置的FIFO（first in，first out）隊列來完成資源獲取線程的排隊工作。

1.1 同步狀態

AQS中維持一個全局的int狀態碼（state），線程通過修改（加/減指定的數量）碼是否成功來決定當前線程是否成功獲取到同步狀態。

1.1 獨占or共用模式

AQS支持兩種獲取同步狀態的模式既獨占式和共用式。顧名思義，獨占式模式同一時刻只允許一個線程獲取同步狀態，而共用模式則允許多個線程同時獲取。

1.2 同步隊列

同步隊列（一個FIFO雙向隊列）是AQS的核心，用來完成同步狀態的管理，當線程獲取同步狀態失敗時，AQS會將當前線程以及等待狀態等信息構造成一個節點並加入到同步隊列，同時會阻塞當前線程。

二，獨占模式獲取與釋放狀態

獨占模式既同一時間只能由一個線程持有同步狀態。當多個線程競爭時(acquire)，獲取到同步狀態的線程會將當前線程賦值給Thread exclusiveOwnerThread屬性（AQS父類中）來標記當前狀態被線程獨占。其他線程將被構造成Node加入到同步隊列中。當線程l

2.1 獲取同步狀態

/**
 * 獲取同步狀態
 */
public final void acquire(int arg) {
    /**
     * 1. tryAcquire    嘗試獲取同步狀態; 
     * 2.1 addWaiter     如果嘗試獲取到同步狀態失敗，則加入到同步隊列中; 
     * 2.2 acquireQueued 在隊列中嘗試獲取同步狀態.
     */
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

  1. 多線程併發獲取（修改）同步狀態, 修改同步狀態成功的線程標記為擁有同步狀態

    /**
 * 嘗試獲取同步狀態【子類中實現】，因為aqs基於模板模式，僅提供基於狀態和同步隊列的實 
 * 現框架，具體的實現邏輯由子類決定
 */
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        // a. 嘗試修改狀態值操作執行成功
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            // b. 修改狀態值成功，記錄當前持有同步狀態的線程信息
            setExclusiveOwnerThread(current);
            return true;
        }
        // 如果當前線程已經持有同步狀態，繼續修改同步狀態【重入鎖實現原理，不理解可以先忽略】
    } else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

  2. 獲取失敗的線程，加入到同步隊列的隊尾；加入到隊列中後，如果當前節點的前驅節點為頭節點再次嘗試獲取同步狀態（下文代碼：p == head && tryAcquire(arg)）。

    /**
 * 沒有獲取到同步狀態的線程加入到隊尾部
 */
private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    // 嘗試用最快的方式入隊，如果入隊失敗，再走完整的入隊方法
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        // 將當前線程設置到隊尾
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 正常的入隊方法
    enq(node);
    return node;
}

/**
 * 同步隊列中節點，嘗試獲取同步狀態
 */
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        // 自旋(死迴圈)
        for (;;) {
         // 只有當前節點的前驅節點是頭節點時才會嘗試執行獲取同步狀態操作
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                setHead(node);// 註意： 此處重點， 當前節點設置為頭節點，相當於頭節點出隊
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            // 獲取失敗後是否進入wait
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}
    1. 如果頭節點的下一個節點嘗試獲取同步狀態失敗後，會進入等待狀態；其他節點則繼續自旋。

// 偽代碼
final boolean acquireQueued(final Node node, int arg) {
    for (;;) {
        // -------獲取同步狀態失敗-------
      
        // 獲取失敗後是否進入wait
        if (shouldParkAfterFailedAcquire(p, node) &&
            parkAndCheckInterrupt())
            interrupted = true;
    }
 
}
/**
 * 當獲取同步狀態失敗後是否進入park狀態
 */
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    // 前驅節點為喚醒狀態，返回true【後面代碼暫時可以忽略】
    if (ws == Node.SIGNAL)
        return true;
    if (ws > 0) {
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

  1. 獨占模式獲取同步狀態總結

2.2 釋放同步狀態

當線程執行完相應邏輯後，需要釋放同步狀態，使後繼節點有機會同步狀態（讓出資源，讓排隊的線程使用）。這時就需要調用release(int arg)方法。調用該方法後，會喚醒後繼節點。

  1. 釋放同步狀態，喚醒後繼節點

/**
 * 釋放同步狀態
 */
public final boolean release(int arg) {
    // 1. 嘗試釋放同步狀態
    if (tryRelease(arg)) {
        Node h = head;
        // 釋放成功後，執行unpark，既喚醒操作（暫時可忽略waitStatus，涉及到條件隊列）
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}     
/**
 * 嘗試釋放同步狀態，既將同步狀態減去指定的值
 * 如果state = 0，表示當前線程  獲取次數 = 釋放次數，既釋放成功，此時將持有同步狀態線程標誌為null
 */
protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // 狀態碼=0，表示釋放成功了
    if (c == 0) {
        free = true;
        // 獨占標誌設置為null
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}
/**
  * 喚醒後繼節點操作
  */
private void unparkSuccessor(Node node) {
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
    // 獲取後繼節點
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    // 喚醒後繼節點
    if (s != null)
        LockSupport.unpark(s.thread);
}

  1. 後繼節點獲取同步狀態成功，頭節點出隊。需要註意的事，出隊操作是間接的，有節點獲取到同步狀態時，會將當前節點設置為head，而原本的head設置為null。

/**
 * 同步隊列中節點，嘗試獲取同步狀態（偽代碼）
 * 獲取成功後，當前節點設置為頭節點，頭節點設置為null，既頭節點出隊
 */
final boolean acquireQueued(final Node node, int arg) {
    try {
        // 自旋(死迴圈)
        for (;;) {
            if (p == head && tryAcquire(arg)) {
                // a. 操作：當前節點設置為頭節點，當前節點的前驅節點設置為null
                setHead(node);
                // b. 原始的head的next設置為null，此時原始的head已經被移出隊列
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
        }
    }
}
/**
 * a.當前節點設置為頭節點，當前節點的前驅節點設置為null
 */
private void setHead(Node node) {
    head = node;
    node.thread = null;
    node.prev = null;
}

2.3 其他競爭情況

  1. 當同步隊列中頭節點喚醒後繼節點時，此時可能有其他線程嘗試獲取同步狀態。

  2. 假設獲取成功，將會被設置為頭節點。

  3. 頭節點後續節點獲取同步狀態失敗。

三，共用模式獲取與釋放狀態

共用模式和獨占模式最主要的區別是在支持同一時刻有多個線程同時獲取同步狀態。為了避免帶來額外的負擔，在上文中提到的同步隊列中都是用獨占模式進行講述，其實同步隊列中的節點應該是獨占和共用節點並存的。

接下來將針對共用模式狀態下獲取與釋放狀態的過程，圖文並茂得進行分析。

3.1 獲取同步狀態

  1. 首先至少要調用一次tryAcquireShared(arg)方法，如果返回值大於等於0表示獲取成功。

  2. 當獲取鎖失敗時，則創建一個共用類型的節點併進入一個同步隊列，然後進入隊列中進入自旋狀態（阻塞，喚醒兩種狀態來回切換，直到獲取到同步狀態為止）

  3. 當隊列中的等待線程被喚醒以後就重新嘗試獲取鎖資源，如果成功則喚醒後面還在等待的共用節點並把該喚醒事件傳遞下去，即會依次喚醒在該節點後面的所有共用節點，否則繼續掛起等待。

當一個同享節點獲取到同步狀態，並喚醒後面等待的共用狀態的結果如下圖所示：

/**
  * 共用模式獲取同步狀態；
  * 1. 首先至少要調用一次tryAcquireShared(arg)方法，如果返回值大於等於0表示獲取成功，直接返回結果即可
  * 2. 否則，將會加入到同步隊列中，反覆阻塞與喚醒，直到獲取同步狀態成功為止； 獲取成功後會喚醒後面還在等待的共用節點並把該喚醒事件傳遞下去，即會依次喚醒在該節點後面的所有共用節點
  */
public final void acquireShared(int arg) {
    if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
}

/**
  * 2. 自旋模式獲取同步狀態
  */
private void doAcquireShared(int arg) {
    // 2.1 第一次獲取失敗後，會將此線程加入到同步隊列中
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            // 如果前驅節點是頭節點，嘗試獲取同步狀態
            final Node p = node.predecessor();
            if (p == head) {
                // r > 0表示獲取同步狀態成功，並且還有共用類型節點在同步隊列中
                // r == 0 表示獲取同步狀態成功，同步隊列中沒有其他共用模式節點
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    // ！！！！ 獲取同步狀態成功後，將當前node設置為頭節點，並向後傳播，喚醒共用模式等待的節點
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    if (interrupted)
                        selfInterrupt();
                    failed = false;
                    return;
                }
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

/**
 * 設置新的頭結點，並設置後面需要喚醒的節點
 */ 
private void setHeadAndPropagate(Node node, int propagate) {
    Node h = head; // Record old head for check below
    setHead(node);
    // propagate > 0 表明後面需要喚醒的共用模式節點
    if (propagate > 0 || h == null || h.waitStatus < 0 ||
        (h = head) == null || h.waitStatus < 0) {
        Node s = node.next;
         // 如果當前節點的後繼節點是共用類型或者沒有後繼節點，則進行喚醒
         // 這裡可以理解為除非明確指明不需要喚醒（後繼等待節點是獨占類型），否則都要喚醒
        if (s == null || s.isShared())
            doReleaseShared();
    }
}
/**
 * 喚醒所有共用模式節點
 */
private void doReleaseShared() {
        for (;;) {
            // 喚醒操作由頭結點開始，註意這裡的頭節點已經是上面新設置的頭結點了
            // 其實就是喚醒上面新獲取到共用鎖的節點的後繼節點
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                // 表示後繼節點需要被喚醒
                if (ws == Node.SIGNAL) {
                    //這裡需要控制併發，因為入口有setHeadAndPropagate跟release兩個，避免兩次unpark
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;      
                    //執行喚醒操作      
                    unparkSuccessor(h);
                }
                //如果後繼節點暫時不需要喚醒，則把當前節點狀態設置為PROPAGATE確保以後可以傳遞下去
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                
            }
            // 如果頭結點沒有發生變化，表示設置完成，退出迴圈
            // 如果頭結點發生變化，比如說其他線程獲取到了鎖，為了使自己的喚醒動作可以傳遞，必須進行重試
            if (h == head)                   
                break;
        }
    }

最後，獲取到同步狀態的線程執行完畢，同步隊列中只有一個獨占節點：

3.2 釋放同步狀態

釋放同步狀態後，同步隊列的變化過程和共用節點獲取到同步狀態後的變化過程一致，此處不再進行贅述。

/**
 * 釋放同步狀態，如果釋放成功，喚醒後面等待的節點
 *
 */
public final boolean releaseShared(int arg) {
    // 1. 嘗試釋放同步狀態
    if (tryReleaseShared(arg)) {
         // 2. 釋放成功後，喚醒後續等待共用節點
         doReleaseShared();
        return true;
    }
    return false;
}

四，基於AQS實現互斥鎖

讀到此處，大部分人應該還比較懵逼，似懂非懂。接下來筆者將通過AQS實現一個互斥鎖帶你打開AQS的正確打開姿勢。

多線程環境count += 1可能會存在問題，詳情可以看在併發編程bug的來源中介紹的三大原因。正如大多數人都知道的，我們通常可以使用synchronized關鍵字進行同步，接下來我們就基於AQS自定義一個互斥鎖來完成相同的功能。

4.1 代碼實現

/**
 * 自定義互斥鎖
 *
 * @author cruder
 * @time 2019/11/29 23:23
 */
public class MutexLock {

    private static final Sync STATE_HOLDER = new Sync();

    /**
     * 通過Sync內部類來持有同步狀態， 當狀態為1表示鎖被持有，0表示鎖處於空閑狀態
     */
    private static class Sync extends AbstractQueuedSynchronizer {

        /**
         * 是否被獨占， 有兩種表示方式
         *  1. 可以根據狀態，state=1表示鎖被占用，0表示空閑
         *  2. 可以根據當前獨占鎖的線程來判斷，即getExclusiveOwnerThread()!=null 表示被獨占
         */
        @Override
        protected boolean isHeldExclusively() {
            return getExclusiveOwnerThread() != null;
        }

        /**
         * 嘗試獲取鎖，將狀態從0修改為1，操作成功則將當前線程設置為當前獨占鎖的線程
         */
        @Override
        protected boolean tryAcquire(int arg) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        /**
         * 釋放鎖，將狀態修改為0
         */
        @Override
        protected boolean tryRelease(int arg) {
            if (getState() == 0) {
                throw new UnsupportedOperationException();
            }
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

    }

    /**
     * 下麵的實現Lock介面需要重寫的方法，基本是就是調用內部內Sync的方法
     */
    public void lock() {
        STATE_HOLDER.acquire(1);
    }

    public void unlock() {
        STATE_HOLDER.release(1);
    }
}

4.2 鎖的測試

我們定義一個計數器類，裡面定義了2個不同的計數方法，其中一個使用互斥鎖進行同步。開啟10個線程併發執行，每個線程計數10000次，然後對比統計結果與預期的100，000是否相符。

package myLock;

import java.util.concurrent.*;

/**
 * 自定義鎖測試
 *
 * @author liqiang
 * @time 2019/11/29 12:39
 */
public class MyLockTest {

    public static void main(String[] args) throws InterruptedException {
        int threadNum = 10;
        int countPerThread = 10000;
        // 線程池創建的正確姿勢
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(threadNum, threadNum, 1000, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10), new ThreadPoolExecutor.AbortPolicy());
        CountDownLatch countDownLatch = new CountDownLatch(threadNum);
        Counter counter = new Counter();
        Counter counterUnsafe = new Counter();

        for (int i = 0; i < threadNum; i++) {
            threadPool.submit(() -> {
                for (int j = 0; j < countPerThread; j++) {
                    counter.getAndIncrement();
                    counterUnsafe.getAndIncrementUnSfae();
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        System.out.printf("%s 個線程，每個線程累加了 %s 次，執行結果：safeCounter = %s, unsafeCounter = %s ", threadNum, countPerThread, counter.get(), counterUnsafe.get());
        threadPool.shutdownNow();
    }

}

class Counter {
    private MutexLock mutexLock;
    private volatile int count;

    Counter() {
        this.mutexLock = new MutexLock();
    }

    int get() {
        return count;
    }

    int getAndIncrement() {
        mutexLock.lock();
        count++;
        mutexLock.unlock();
        return count;
    }

    int getAndIncrementUnSfae() {
        count++;
        return count;
    }
}

1575039419566

結果和預期一樣，用自定義鎖實現的計數器統計沒有誤差。

五，總結

  1. AQS通過一個int同步狀態碼，和一個（先進先出）隊列來控制多個線程訪問資源
  2. 支持獨占和共用兩種模式獲取同步狀態碼
  3. 當線程獲取同步狀態失敗會被加入到同步隊列中
  4. 當線程釋放同步狀態，會喚醒後繼節點來獲取同步狀態
  5. 共用模式下的節點獲取到同步狀態或者釋放同步狀態時，不僅會喚醒後繼節點，還會向後傳播，喚醒所有同步節點
  6. 使用volatile關鍵字保證狀態碼線上程間的可見性，CAS操作保證修改狀態碼過程的原子性。

AQS的設計與實現比本文中描述的要稍微複雜一些，為了達到快速入門的效果所以本文進行了簡化。對於沒有講到的內容，比如，對於獨占模式下超時獲取同步狀態， 隊列中節點狀態的流轉， 條件隊列等沒有講到的內容，將會放到下一篇文章中進行介紹。

六，Q&A

Question1： 在java中通常使用synchronized來實現方法同步，AQS中通過CAS保證了修改同步狀態的一致性問題，那麼對比synchronized，cas有什麼優勢不同與優勢呢？你還知道其他無鎖併發的策略嗎？

我的相關文章：

一文搞懂併發編程bug的來源

無鎖併發的CAS為何如此優秀

參考：

https://www.jianshu.com/p/1161d33fc1d0

《Java併發編程的藝術》

《Java併發編程實戰》


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

-Advertisement-
Play Games
更多相關文章
  • google跟蹤代碼管理器gtm無法給相同class元素綁定click事件埋點解決
    Google 跟蹤代碼管理器是一個跟蹤代碼管理系統 (TMS)，可以幫助您快速輕鬆地更新網站或移動應用上的跟蹤代碼及相關代碼段（統稱為“代碼”）。將一小段跟蹤代碼管理器代碼添加到項目後，您可以通過網頁界面安全輕鬆地部署 Google Analytics（分析）和衡量代碼配置。 在通過clickCla ...
  • JS基礎語法---預解析
    預解析:就是在解析代碼之前 1. 預解析做什麼事? 把變數的聲明提前了 提前到當前所在的作用域的最上面 函數的聲明也會被提前 提前到當前所在的作用域的最上面 舉例： function f1() { console.log(num); var num = 10; } f1(); //此時運行結果是un ...
  • JS基礎語法---作用域鏈
    從函數嵌套來分析： （層數一般5層內） var num=10; function f1() { var num=20; function f2() { var num=30; function f3() { var num=50; console.log(num); } f3(); } f2(); ...
  • 關於angularjs非同步操作後臺請求時，用$q.all排列先後順序的問題
    最近我在做angularjs程式時遇到了一個問題 1.頁面有很多選擇框，一個選擇框裡面有眾多的選擇項，和一個預設選定的項,像下麵這樣（很多選擇框，不只一個）： 2.眾多的選項要從後臺介面得到，預設項從另一個後臺介面得到，這就需要$promise.then（）操作 3.而多個$promise.then ...
  • 用Helm3構建多層微服務
    Helm是一款非常流行的k8s包管理工具。以前就一直想用它，但看到它產生的文件比k8s要複雜許多，就一直猶豫，不知道它的好處能不能抵消掉它的複雜度。但如果不用，而是用Kubectl來進行調式真的很麻煩。正好最近Helm3正式版出來了，比原來的Helm2簡單了不少，就決定還是試用一下。結果證明確實很復 ...
  • 慕課網 實戰班 就業班 2019年11月30號 更新資料整理 300套 只讀模式打開
    慕課網 實戰班 就業班 2019年11月30號 更新資料整理 300套 只讀模式打開 百度網盤資料鏈接： 鏈接：https://pan.baidu.com/s/1qORPsgM6ukDPOSjU5ck5yA 提取碼：qnlu 複製這段內容後打開百度網盤手機App，操作更方便哦 微雲鏈接： https ...
  • Java連載55-介面的作用、介面舉例
    一、介面的作用 1.可以使項目分層，所有層都面向介面開發，開發效率提高了。 2.介面使代碼和代碼之間的耦合度降低，就像記憶體條和主板的關係，變得“可插拔”，可以隨意切換。 ​總結：介面和抽象類能夠完成某個功能，優先選擇介面。因為介面可以多實現、​多繼承。並且一個類除了實現介面之外，還可以去繼承其他類（ ...
  • SSM框架整合 詳細步驟(備註) 附源碼
    整合思路 將工程的三層結構中的JavaBean分別使用Spring容器(通過XML方式)進行管理。 整合持久層mapper，包括數據源、會話工程及mapper代理對象的整合； 整合業務層Service，包括事務及service的bean的配置； 整合表現層Controller，直接使用springm ...
一周排行
    -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.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類