C#多線程編程系列（三）- 線程同步

来源:https://www.cnblogs.com/InCerry/archive/2018/08/03/9416382.html
-Advertisement-
Play Games

[TOC] 1.1 簡介 本章介紹在C 中實現線程同步的幾種方法。因為多個線程同時訪問共用數據時，可能會造成共用數據的損壞，從而導致與預期的結果不相符。為瞭解決這個問題，所以需要用到線程同步，也被俗稱為“加鎖”。但是 加鎖絕對不對提高性能，最多也就是不增不減 ，要實現性能不增不減還得靠高質量的 同步 ...


目錄

1.1 簡介

本章介紹在C#中實現線程同步的幾種方法。因為多個線程同時訪問共用數據時，可能會造成共用數據的損壞，從而導致與預期的結果不相符。為瞭解決這個問題，所以需要用到線程同步，也被俗稱為“加鎖”。但是加鎖絕對不對提高性能，最多也就是不增不減，要實現性能不增不減還得靠高質量的同步源語(Synchronization Primitive)。但是因為正確永遠比速度更重要，所以線程同步在某些場景下是必須的。

線程同步有兩種源語(Primitive)構造：用戶模式(user - mode)和內核模式(kernel - mode)，當資源可用時間短的情況下，用戶模式要優於內核模式，但是如果長時間不能獲得資源，或者說長時間處於“自旋”，那麼內核模式是相對來說好的選擇。

但是我們希望兼具用戶模式和內核模式的優點，我們把它稱為混合構造(hybrid construct)，它兼具了兩種模式的優點。

在C#中有多種線程同步的機制，通常可以按照以下順序進行選擇。

  1. 如果代碼能通過優化可以不進行同步，那麼就不要做同步。
  2. 使用原子性的Interlocked方法。
  3. 使用lock/Monitor類。
  4. 使用非同步鎖，如SemaphoreSlim.WaitAsync()。
  5. 使用其它加鎖機制，如ReaderWriterLockSlim、Mutex、Semaphore等。
  6. 如果系統提供了*Slim版本的非同步對象，那麼請選用它，因為*Slim版本全部都是混合鎖，在進入內核模式前實現了某種形式的自旋。

在同步中，一定要註意避免死鎖的發生，死鎖的發生必須滿足以下4個基本條件，所以只需要破壞任意一個條件，就可避免發生死鎖。

  1. 排他或互斥(Mutual exclusion)：一個線程(ThreadA)獨占一個資源，沒有其它線程(ThreadB)能獲取相同的資源。
  2. 占有並等待(Hold and wait)：互斥的一個線程(ThreadA)請求獲取另一個線程(ThreadB)占有的資源.
  3. 不可搶先(No preemption)：一個線程(ThreadA)占有資源不能被強制拿走(只能等待ThreadA主動釋放它的資源)。
  4. 迴圈等待條件(Circular wait condition)：兩個或多個線程構成一個迴圈等待鏈，它們鎖定兩個或多個相同的資源，每個線程都在等待鏈中的下一個線程占有的資源。

1.2 執行基本原子操作

CLR保證了對這些數據類型的讀寫是原子性的：Boolean、Char、(S)Byte、(U)Int16、(U)Int32、(U)IntPtr和Single。但是如果讀寫Int64可能會發生讀取撕裂(torn read)的問題，因為在32位操作系統中，它需要執行兩次Mov操作，無法在一個時間內執行完成。

那麼在本節中，就會著重的介紹System.Threading.Interlocked類提供的方法，Interlocked類中的每個方法都是執行一次的讀取以及寫入操作。更多與Interlocked類相關的資料請參考鏈接，戳一戳本文不在贅述。

演示代碼如下所示，分別使用了三種方式進行計數：錯誤計數方式、lock鎖方式和Interlocked原子方式。

private static void Main(string[] args)
{
    Console.WriteLine("錯誤的計數");

    var c = new Counter();
    Execute(c);

    Console.WriteLine("--------------------------");


    Console.WriteLine("正確的計數 - 有鎖");

    var c2 = new CounterWithLock();
    Execute(c2);

    Console.WriteLine("--------------------------");


    Console.WriteLine("正確的計數 - 無鎖");

    var c3 = new CounterNoLock();
    Execute(c3);

    Console.ReadLine();
}

static void Execute(CounterBase c)
{
    // 統計耗時
    var sw = new Stopwatch();
    sw.Start();

    var t1 = new Thread(() => TestCounter(c));
    var t2 = new Thread(() => TestCounter(c));
    var t3 = new Thread(() => TestCounter(c));
    t1.Start();
    t2.Start();
    t3.Start();
    t1.Join();
    t2.Join();
    t3.Join();

    sw.Stop();
    Console.WriteLine($"Total count: {c.Count} Time:{sw.ElapsedMilliseconds} ms");
}

static void TestCounter(CounterBase c)
{
    for (int i = 0; i < 100000; i++)
    {
        c.Increment();
        c.Decrement();
    }
}

class Counter : CounterBase
{
    public override void Increment()
    {
        _count++;
    }

    public override void Decrement()
    {
        _count--;
    }
}

class CounterNoLock : CounterBase
{
    public override void Increment()
    {
        // 使用Interlocked執行原子操作
        Interlocked.Increment(ref _count);
    }

    public override void Decrement()
    {
        Interlocked.Decrement(ref _count);
    }
}

class CounterWithLock : CounterBase
{
    private readonly object _syncRoot = new Object();

    public override void Increment()
    {
        // 使用Lock關鍵字 鎖定私有變數
        lock (_syncRoot)
        {
            // 同步塊
            Count++;
        }
    }

    public override void Decrement()
    {
        lock (_syncRoot)
        {
            Count--;
        }
    }
}


abstract class CounterBase
{
    protected int _count;

    public int Count
    {
        get
        {
            return _count;
        }
        set
        {
            _count = value;
        }
    }

    public abstract void Increment();

    public abstract void Decrement();
}

運行結果如下所示，與預期結果基本相符。

1533267651508

1.3 使用Mutex類

System.Threading.Mutex在概念上和System.Threading.Monitor幾乎一樣，但是Mutex同步對文件或者其他跨進程的資源進行訪問，也就是說Mutex是可跨進程的。因為其特性，它的一個用途是限制應用程式不能同時運行多個實例。

Mutex對象支持遞歸，也就是說同一個線程可多次獲取同一個鎖，這在後面演示代碼中可觀察到。由於Mutex的基類System.Theading.WaitHandle實現了IDisposable介面，所以當不需要在使用它時要註意進行資源的釋放。更多資料：戳一戳

演示代碼如下所示，簡單的演示瞭如何創建單實例的應用程式和Mutex遞歸獲取鎖的實現。

const string MutexName = "CSharpThreadingCookbook";

static void Main(string[] args)
{
    // 使用using 及時釋放資源
    using (var m = new Mutex(false, MutexName))
    {
        if (!m.WaitOne(TimeSpan.FromSeconds(5), false))
        {
            Console.WriteLine("已經有實例正在運行!");
        }
        else
        {

            Console.WriteLine("運行中...");

            // 演示遞歸獲取鎖
            Recursion();

            Console.ReadLine();
            m.ReleaseMutex();
        }
    }

    Console.ReadLine();
}

static void Recursion()
{
    using (var m = new Mutex(false, MutexName))
    {
        if (!m.WaitOne(TimeSpan.FromSeconds(2), false))
        {
            // 因為Mutex支持遞歸獲取鎖 所以永遠不會執行到這裡
            Console.WriteLine("遞歸獲取鎖失敗！");
        }
        else
        {
            Console.WriteLine("遞歸獲取鎖成功！");
        }
    }
}

運行結果如下圖所示，打開了兩個應用程式，因為使用Mutex實現了單實例，所以第二個應用程式無法獲取鎖，就會顯示已有實例正在運行。

1533278259064

1.4 使用SemaphoreSlim類

SemaphoreSlim類與之前提到的同步類有鎖不同，之前提到的同步類都是互斥的，也就是說只允許一個線程進行訪問資源，而SemaphoreSlim是可以允許多個訪問。

在之前的部分有提到，以*Slim結尾的線程同步類，都是工作在混合模式下的，也就是說開始它們都是在用戶模式下"自旋"，等發生第一次競爭時，才切換到內核模式。但是SemaphoreSlim不同於Semaphore類，它不支持系統信號量，所以它不能用於進程之間的同步。

該類使用比較簡單，演示代碼演示了6個線程競爭訪問只允許4個線程同時訪問的資料庫，如下所示。

static void Main(string[] args)
{
    // 創建6個線程 競爭訪問AccessDatabase
    for (int i = 1; i <= 6; i++)
    {
        string threadName = "線程 " + i;
        // 越後面的線程，訪問時間越久 方便查看效果
        int secondsToWait = 2 + 2 * i;
        var t = new Thread(() => AccessDatabase(threadName, secondsToWait));
        t.Start();
    }

    Console.ReadLine();
}

// 同時允許4個線程訪問
static SemaphoreSlim _semaphore = new SemaphoreSlim(4);

static void AccessDatabase(string name, int seconds)
{
    Console.WriteLine($"{name} 等待訪問資料庫.... {DateTime.Now.ToString("HH:mm:ss.ffff")}");

    // 等待獲取鎖 進入臨界區
    _semaphore.Wait();

    Console.WriteLine($"{name} 已獲取對資料庫的訪問許可權 {DateTime.Now.ToString("HH:mm:ss.ffff")}");
    // Do something
    Thread.Sleep(TimeSpan.FromSeconds(seconds));

    Console.WriteLine($"{name} 訪問完成... {DateTime.Now.ToString("HH:mm:ss.ffff")}");
    // 釋放鎖
    _semaphore.Release();
}

運行結果如下所示，可見前4個線程馬上就獲取到了鎖，進入了臨界區，而另外兩個線程在等待；等有鎖被釋放時，才能進入臨界區。1533281733322

1.5 使用AutoResetEvent類

AutoResetEvent叫自動重置事件，雖然名稱中有事件一詞，但是重置事件和C#中的委托沒有任何關係，這裡的事件只是由內核維護的Boolean變數，當事件為false，那麼在事件上等待的線程就阻塞；事件變為true，那麼阻塞解除。

在.Net中有兩種此類事件，即AutoResetEvent(自動重置事件)和ManualResetEvent(手動重置事件)。這兩者均是採用內核模式，它的區別在於當重置事件為true時，自動重置事件它只喚醒一個阻塞的線程，會自動將事件重置回false，造成其它線程繼續阻塞。而手動重置事件不會自動重置，必須通過代碼手動重置回false。

因為以上的原因，所以在很多文章和書籍中不推薦使用AutoResetEvent(自動重置事件)，因為它很容易在編寫生產者線程時發生失誤，造成它的迭代次數多餘消費者線程。

演示代碼如下所示，該代碼演示了通過AutoResetEvent實現兩個線程的互相同步。

static void Main(string[] args)
{
    var t = new Thread(() => Process(10));
    t.Start();

    Console.WriteLine("等待另一個線程完成工作！");
    // 等待工作線程通知 主線程阻塞
    _workerEvent.WaitOne();
    Console.WriteLine("第一個操作已經完成！");
    Console.WriteLine("在主線程上執行操作");
    Thread.Sleep(TimeSpan.FromSeconds(5));

    // 發送通知 工作線程繼續運行
    _mainEvent.Set();
    Console.WriteLine("現在在第二個線程上運行第二個操作");

    // 等待工作線程通知 主線程阻塞
    _workerEvent.WaitOne();
    Console.WriteLine("第二次操作完成！");

    Console.ReadLine();
}

// 工作線程Event
private static AutoResetEvent _workerEvent = new AutoResetEvent(false);
// 主線程Event
private static AutoResetEvent _mainEvent = new AutoResetEvent(false);

static void Process(int seconds)
{
    Console.WriteLine("開始長時間的工作...");
    Thread.Sleep(TimeSpan.FromSeconds(seconds));
    Console.WriteLine("工作完成!");

    // 發送通知 主線程繼續運行
    _workerEvent.Set();
    Console.WriteLine("等待主線程完成其它工作");

    // 等待主線程通知 工作線程阻塞
    _mainEvent.WaitOne();
    Console.WriteLine("啟動第二次操作...");
    Thread.Sleep(TimeSpan.FromSeconds(seconds));
    Console.WriteLine("工作完成!");

    // 發送通知 主線程繼續運行
    _workerEvent.Set();
}

運行結果如下圖所示，與預期結果符合。

1533286221209

1.6 使用ManualResetEventSlim類

ManualResetEventSlim使用和ManualResetEvent類基本一致，只是ManualResetEventSlim工作在混合模式下，而它與AutoResetEventSlim不同的地方就是需要手動重置事件，也就是調用Reset()才能將事件重置為false。

演示代碼如下，形象的將ManualResetEventSlim比喻成大門，當事件為true時大門打開，線程解除阻塞；而事件為false時大門關閉，線程阻塞。

static void Main(string[] args)
        {
            var t1 = new Thread(() => TravelThroughGates("Thread 1", 5));
            var t2 = new Thread(() => TravelThroughGates("Thread 2", 6));
            var t3 = new Thread(() => TravelThroughGates("Thread 3", 12));
            t1.Start();
            t2.Start();
            t3.Start();

            // 休眠6秒鐘  只有Thread 1小於 6秒鐘，所以事件重置時 Thread 1 肯定能進入大門  而 Thread 2 可能可以進入大門
            Thread.Sleep(TimeSpan.FromSeconds(6));
            Console.WriteLine($"大門現在打開了!  時間：{DateTime.Now.ToString("mm:ss.ffff")}");
            _mainEvent.Set();

            // 休眠2秒鐘 此時 Thread 2 肯定可以進入大門
            Thread.Sleep(TimeSpan.FromSeconds(2));
            _mainEvent.Reset();
            Console.WriteLine($"大門現在關閉了! 時間：{DateTime.Now.ToString("mm: ss.ffff")}");

            // 休眠10秒鐘 Thread 3 可以進入大門
            Thread.Sleep(TimeSpan.FromSeconds(10));
            Console.WriteLine($"大門現在第二次打開! 時間：{DateTime.Now.ToString("mm: ss.ffff")}");
            _mainEvent.Set();
            Thread.Sleep(TimeSpan.FromSeconds(2));

            Console.WriteLine($"大門現在關閉了! 時間：{DateTime.Now.ToString("mm: ss.ffff")}");
            _mainEvent.Reset();

            Console.ReadLine();
        }

        static void TravelThroughGates(string threadName, int seconds)
        {
            Console.WriteLine($"{threadName} 進入睡眠 時間：{DateTime.Now.ToString("mm:ss.ffff")}");
            Thread.Sleep(TimeSpan.FromSeconds(seconds));

            Console.WriteLine($"{threadName} 等待大門打開! 時間：{DateTime.Now.ToString("mm:ss.ffff")}");
            _mainEvent.Wait();

            Console.WriteLine($"{threadName} 進入大門! 時間：{DateTime.Now.ToString("mm:ss.ffff")}");
        }

        static ManualResetEventSlim _mainEvent = new ManualResetEventSlim(false);

運行結果如下，與預期結果相符。

1533287222335

1.7 使用CountDownEvent類

CountDownEvent類內部構造使用了一個ManualResetEventSlim對象。這個構造阻塞一個線程，直到它內部計數器(CurrentCount)變為0時，才解除阻塞。也就是說它並不是阻止對已經枯竭的資源池的訪問，而是只有當計數為0時才允許訪問。

這裡需要註意的是，當CurrentCount變為0時，那麼它就不能被更改了。為0以後，Wait()方法的阻塞被解除。

演示代碼如下所示，只有當Signal()方法被調用2次以後，Wait()方法的阻塞才被解除。

static void Main(string[] args)
{
    Console.WriteLine($"開始兩個操作  {DateTime.Now.ToString("mm:ss.ffff")}");
    var t1 = new Thread(() => PerformOperation("操作 1 完成！", 4));
    var t2 = new Thread(() => PerformOperation("操作 2 完成！", 8));
    t1.Start();
    t2.Start();

    // 等待操作完成
    _countdown.Wait();
    Console.WriteLine($"所有操作都完成  {DateTime.Now.ToString("mm: ss.ffff")}");
    _countdown.Dispose();

    Console.ReadLine();
}

// 構造函數的參數為2 表示只有調用了兩次 Signal方法 CurrentCount 為 0時  Wait的阻塞才解除
static CountdownEvent _countdown = new CountdownEvent(2);

static void PerformOperation(string message, int seconds)
{
    Thread.Sleep(TimeSpan.FromSeconds(seconds));
    Console.WriteLine($"{message}  {DateTime.Now.ToString("mm:ss.ffff")}");

    // CurrentCount 遞減 1
    _countdown.Signal();
}

運行結果如下圖所示，可見只有當操作1和操作2都完成以後，才執行輸出所有操作都完成。

1533296843834

1.8 使用Barrier類

Barrier類用於解決一個非常稀有的問題，平時一般用不上。Barrier類控制一系列線程進行階段性的並行工作。

假設現在並行工作分為2個階段，每個線程在完成它自己那部分階段1的工作後，必須停下來等待其它線程完成階段1的工作；等所有線程均完成階段1工作後，每個線程又開始運行，完成階段2工作，等待其它線程全部完成階段2工作後，整個流程才結束。

演示代碼如下所示，該代碼演示了兩個線程分階段的完成工作。

static void Main(string[] args)
{
    var t1 = new Thread(() => PlayMusic("鋼琴家", "演奏一首令人驚嘆的獨奏曲", 5));
    var t2 = new Thread(() => PlayMusic("歌手", "唱著他的歌", 2));

    t1.Start();
    t2.Start();

    Console.ReadLine();
}

static Barrier _barrier = new Barrier(2,
 Console.WriteLine($"第 {b.CurrentPhaseNumber + 1} 階段結束"));

static void PlayMusic(string name, string message, int seconds)
{
    for (int i = 1; i < 3; i++)
    {
        Console.WriteLine("----------------------------------------------");
        Thread.Sleep(TimeSpan.FromSeconds(seconds));
        Console.WriteLine($"{name} 開始 {message}");
        Thread.Sleep(TimeSpan.FromSeconds(seconds));
        Console.WriteLine($"{name} 結束 {message}");
        _barrier.SignalAndWait();
    }
}

運行結果如下所示，當“歌手”線程完成後，並沒有馬上結束，而是等待“鋼琴家”線程結束，當"鋼琴家"線程結束後，才開始第2階段的工作。

1533297859508

1.9 使用ReaderWriterLockSlim類

ReaderWriterLockSlim類主要是解決在某些場景下，讀操作多於寫操作而使用某些互斥鎖當多個線程同時訪問資源時，只有一個線程能訪問，導致性能急劇下降。

如果所有線程都希望以只讀的方式訪問數據，就根本沒有必要阻塞它們；如果一個線程希望修改數據，那麼這個線程才需要獨占訪問，這就是ReaderWriterLockSlim的典型應用場景。這個類就像下麵這樣來控制線程。

  • 一個線程向數據寫入是，請求訪問的其他所有線程都被阻塞。
  • 一個線程讀取數據時，請求讀取的線程允許讀取，而請求寫入的線程被阻塞。
  • 寫入線程結束後，要麼解除一個寫入線程的阻塞，使寫入線程能向數據接入，要麼解除所有讀取線程的阻塞，使它們能併發讀取數據。如果線程沒有被阻塞，鎖就可以進入自由使用的狀態，可供下一個讀線程或寫線程獲取。
  • 從數據讀取的所有線程結束後，一個寫線程被解除阻塞，使它能向數據寫入。如果線程沒有被阻塞，鎖就可以進入自由使用的狀態，可供下一個讀線程或寫線程獲取。

ReaderWriterLockSlim還支持從讀線程升級為寫線程的操作，詳情請戳一戳。文本不作介紹。ReaderWriterLock類已經過時，而且存在許多問題，沒有必要去使用。

示例代碼如下所示，創建了3個讀線程，2個寫線程，讀線程和寫線程競爭獲取鎖。

static void Main(string[] args)
{
    // 創建3個 讀線程
    new Thread(() => Read("Reader 1")) { IsBackground = true }.Start();
    new Thread(() => Read("Reader 2")) { IsBackground = true }.Start();
    new Thread(() => Read("Reader 3")) { IsBackground = true }.Start();

    // 創建兩個寫線程
    new Thread(() => Write("Writer 1")) { IsBackground = true }.Start();
    new Thread(() => Write("Writer 2")) { IsBackground = true }.Start();

    // 使程式運行30S
    Thread.Sleep(TimeSpan.FromSeconds(30));

    Console.ReadLine();
}

static ReaderWriterLockSlim _rw = new ReaderWriterLockSlim();
static Dictionary<int, int> _items = new Dictionary<int, int>();

static void Read(string threadName)
{
    while (true)
    {
        try
        {
            // 獲取讀鎖定
            _rw.EnterReadLock();
            Console.WriteLine($"{threadName} 從字典中讀取內容  {DateTime.Now.ToString("mm:ss.ffff")}");
            foreach (var key in _items.Keys)
            {
                Thread.Sleep(TimeSpan.FromSeconds(0.1));
            }
        }
        finally
        {
            // 釋放讀鎖定
            _rw.ExitReadLock();
        }
    }
}

static void Write(string threadName)
{
    while (true)
    {
        try
        {
            int newKey = new Random().Next(250);
            // 嘗試進入可升級鎖模式狀態
            _rw.EnterUpgradeableReadLock();
            if (!_items.ContainsKey(newKey))
            {
                try
                {
                    // 獲取寫鎖定
                    _rw.EnterWriteLock();
                    _items[newKey] = 1;
                    Console.WriteLine($"{threadName} 將新的鍵 {newKey} 添加進入字典中  {DateTime.Now.ToString("mm:ss.ffff")}");
                }
                finally
                {
                    // 釋放寫鎖定
                    _rw.ExitWriteLock();
                }
            }
            Thread.Sleep(TimeSpan.FromSeconds(0.1));
        }
        finally
        {
            // 減少可升級模式遞歸計數，併在計數為0時  推出可升級模式
            _rw.ExitUpgradeableReadLock();
        }
    }
}

運行結果如下所示，與預期結果相符。

1533301318169

1.10 使用SpinWait類

SpinWait是一個常用的混合模式的類，它被設計成使用用戶模式等待一段時間，人後切換至內核模式以節省CPU時間。

它的使用非常簡單，演示代碼如下所示。

static void Main(string[] args)
{
    var t1 = new Thread(UserModeWait);
    var t2 = new Thread(HybridSpinWait);

    Console.WriteLine("運行在用戶模式下");
    t1.Start();
    Thread.Sleep(20);
    _isCompleted = true;
    Thread.Sleep(TimeSpan.FromSeconds(1));
    _isCompleted = false;

    Console.WriteLine("運行在混合模式下");
    t2.Start();
    Thread.Sleep(5);
    _isCompleted = true;

    Console.ReadLine();
}

static volatile bool _isCompleted = false;

static void UserModeWait()
{
    while (!_isCompleted)
    {
        Console.Write(".");
    }
    Console.WriteLine();
    Console.WriteLine("等待結束");
}

static void HybridSpinWait()
{
    var w = new SpinWait();
    while (!_isCompleted)
    {
        w.SpinOnce();
        Console.WriteLine(w.NextSpinWillYield);
    }
    Console.WriteLine("等待結束");
}

運行結果如下兩圖所示，首先程式運行在模擬的用戶模式下，使CPU有一個短暫的峰值。然後使用SpinWait工作在混合模式下，首先標誌變數為False處於用戶模式自旋中，等待以後進入內核模式。

1533302799590

1533302772242

參考書籍

本文主要參考了以下幾本書，在此對這些作者表示由衷的感謝你們提供了這麼好的資料。

  1. 《CLR via C#》
  2. 《C# in Depth Third Edition》
  3. 《Essential C# 6.0》
  4. 《Multithreading with C# Cookbook Second Edition》

源碼下載點擊鏈接 示例源碼下載

筆者水平有限，如果錯誤歡迎各位批評指正！


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

-Advertisement-
Play Games
更多相關文章
  • Python實現DDOS攻擊，下個黑客就是你！
    DDOS攻擊的一些基礎知識點在這裡就不再贅述，由於Server端要控制client，所以這裡需要使用argparse，在這裡我們先規定好命令格式：#-H XXX.XXX.XXX.XXX -p xxxx -c<start|stop> -H後面接的是被攻擊主機的IP地址。 -p指定被攻擊的埠號。 -c ...
  • Spring Cloud中異常處理的套路
    異常在Java中有兩種分類：Error（OutOfMemoryError之類的我們自己程式無法處理的非常嚴重的錯誤，Java推薦不catch，讓程式隨之崩潰）、Excepiton（NullPointerException之類的並不致命的錯誤，Java覺得indicates conditions th ...
  • java自學 day6
    StringBuilder用法 StringBuilder str=new StringBuilder（）； 和String用法的區別是 string 對象時恆定不變的，stringBuider對象表示的字元串是可變的。 StringBuilder 類提供了很多方法來操作字元串： 包裝類 基本數據類 ...
  • Spring5源碼解析-Spring框架中的單例和原型bean
    Spring5源碼解析-Spring框架中的單例和原型bean 最近一直有問我單例和原型bean的一些原理性問題，這裡就開一篇來說說的 通過Spring中的依賴註入極大方便了我們的開發。在xml通過<bean>定義(或者通過@Bean在配置類里定義)對象之後，然後只需簡單地使用@Autowired註 ...
  • 淺談python的深淺拷貝
    python中有兩種數據類型：一種是可變數據類型，一種是不可變數據類型 不可變數據類型包括（整型及其他數據類型，字元串及元組） 可變數據類型（列表，集合，字典，類和類實例） 鑒定是否為拷貝還是只是引用計數加1，我們可以用python的內置函數(id())來驗證. 程式運行結果表明s和s1的記憶體地址是 ...
  • Kafka從入門到進階
    1. Apache Kafka是一個分散式流平臺 1.1 流平臺有三個關鍵功能： 1.2 Kafka通常用於兩大類應用： 1.3 有幾個特別重要的概念： Kafka is run as a cluster on one or more servers that can span multiple d ...
  • Python--初識函數
    一:定義 對於代碼塊和功能的封裝和定義 二:函數的定義, 函數名, 函數體以及函數的調用 我們使用def關鍵字來定義函數, 函數的定義語法: 函數名的命名規則和變數基本一致, 函數體就是函數被執行之後要執行的代碼 函數名()的形式用來調用函數. 三:函數的返回 return關鍵字會中斷函數,並返回一 ...
  • Net Core平臺靈活簡單的日誌記錄框架NLog+Mysql組合初體驗
     Net Core平臺靈活簡單的日誌記錄框架NLog初體驗 前幾天分享的"[Net Core集成Exceptionless分散式日誌功能以及全局異常過濾][https://www.cnblogs.com/yilezhu/p/9339017.html]" 有人說比較重量，生產環境部署也比較麻煩。因此 ...
一周排行
    -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.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類