C# 多線程

来源:https://www.cnblogs.com/swbna/archive/2023/05/29/17441578.html
-Advertisement-
Play Games

# 什麼是線程 Thread - 線程是一個可執行路徑，它可以獨立於其它線程執行。 - 每個線程都在操作系統的進程（Process）內執行，而操作系統進程提供了程式運行的獨立環境。 - 單線程應用，在進程的獨立環境里只跑一個線程，所以該線程擁有獨占權 - 多線程應用，單個進程中會跑多個線程，它們會共 ...


什麼是線程 Thread

  • 線程是一個可執行路徑，它可以獨立於其它線程執行。
  • 每個線程都在操作系統的進程（Process）內執行，而操作系統進程提供了程式運行的獨立環境。
  • 單線程應用，在進程的獨立環境里只跑一個線程，所以該線程擁有獨占權
  • 多線程應用，單個進程中會跑多個線程，它們會共用當前的執行環境（尤其是記憶體)

image.png

線程的一些屬性

  • 線程一旦開始執行，lsAlive就是true，線程結柬就變成false。
  • 線程結束的條件就是：線程構造函數傳入的委托結束了執行。
  • 線程一旦結束，就無法再重啟。
  • 每個線程都有個Name屬性，通常用於調試。
    • 線程Name只能設置一次，以後更改會拋出異常。
  • 靜態的Thread.CurrentThread 屬性，會返回當先執行的線程

Join and Sleep

  • 調用Join方法，就可以等待另一個線程結束。
  • 添加超時
    • 調用Join 的時候，可以設置一個超時，用毫秒或者TimeSpan都可以。
      • 如果返回true，那就是線程結束了；如果超時了，就返回false。
  • Thread.Sleep()方法會暫停當前的線程，並等一段時間。
  • 註意：
    • Thread.Sleep(0)這樣調用會導致線程立即放棄本身當前的時間片，自動將CPU移交給其他線程
    • Thread.Yield()做同樣的事情，但是它只會把執行交給同一處理器上的其它線程
    • 當等待 Sleep 或Join的時候，線程處於阻塞的狀態。

image.png

阻塞 Blocking

  • 如果線程的執行由於某種原因導致暫定，那麼就認為該線程被阻塞了。
    • 例如在Sleep或者通過Join 等待其他線程結束。
  • 被阻塞的線程會立即將其處理器的時間片生成給其它線程，從此就不再消耗處理器時間，直到滿足其阻塞條件為止。
  • 可以通過ThreadState這個屬性來判斷線程是否處於被阻塞的狀態：

bool blocked = (someThread.ThreadState & ThreadState.WaitsleepJoin) != 0;

ThreadState

  • ThreadState是一個flags enum，通過按位的形式，可以合併數據的選項。image.png
  • 狀態轉換過程image.png
  • 但是它大部分的枚舉值都沒什麼用，下麵的代碼將ThreadState 剝離為四個最有用的值之一：Unstarted、Running、WaitSleepJoin和 Stopped
  • image.png

解除阻塞 Unblocking

  • 當遇到下列四種情況的時候，就會解除阻塞：
    • 阻塞條件被滿足
    • 操作超時（如果設置超時的話)
    • 通過Thread.Interrupt()進行打斷
    • 通過Thread.Abort()進行中止

上下文切換

  • 當線程陽塞或解除阻塞時，操作系統將執行上下文切換。這會產生少量開銷，通常為1或2微秒。

l/O-bound vs Compute-bound(或 CPU-Bound )

  • 一個花費大部分時間等待某事發生的操作稱為I/O-bound
    • IO綁定操作通常涉及輸入或輸出，但這不是硬性要求:Thread.Sleep()也被視為IO-bound
  • 相反，一個花費大部分時間執行CPU密集型工作的操作稱為Compute-bound。

阻塞Blocking vs 忙等待(自旋)Spinning

  • IO-bound操作的工作方式有兩種
    • 在當前線程上同步的等待 Console.ReadLine(),Thread.Sleep(),Thread.Join()...
    • 非同步的操作，在稍後操作完成時觸發一個回調動作。
  • 同步等待的I/O-bound操作將大部分時間花在阻塞線程上。
  • 它們也可以周期性的在一個迴圈里進行 ”打轉（自旋)“
    while (DateTime.Now < nextStartTime);
  • 在忙等待和阻塞方面有一些細微差別。
    • 首先，如果您希望條件很快得到滿足（可能在幾微秒之內），則短暫自旋可能會很有效，因為它避免了上下文切換的開銷和延遲。
      • .NET Framework提供了特殊的方法和類來提供幫助SpinLock和 SpinWait.
    • 其次，阻塞也不是零成本。這是因為每個線程在生存周期會占用大約1MB的記憶體，並會給CLR和操作系統帶來持續的管理開銷。
      • 因此，在需要處理成百上千個併發操作的大量 IO-bound程式的上下文中，阻塞可能會很麻煩
      • 所以，此類程式需要使用基於回調的方法，在等待時完全撤消其線程。

什麼是線程安全？

本地Local vs 共用的狀態Shared State

Local本地獨立

  • CLR為每個線程分配自己的記憶體棧(Stack) ，以便使本地變數保持獨立。

Shared共用

  • 如果多個線程都引用到同一個對象的實例，那麼它們就共用了數據。
  • 被Lambda表達式或匿名委托所捕獲的本地變數，會被編譯器轉化為欄位( field ) ，所以也會被共用。
  • 靜態欄位(field)也會線上程間共用數據。
internal class Program {
    static bool _done;
    static void Main(string[] args) {
        new Thread(Do).Start();
        Do();
    }

    static void Do() {
        if(!_done) {
            _done = true;
            Console.WriteLine("Done!");
        }
    } 
}

線程安全 Thread Safety

  • 後三個例子就引出了線程安全這個關鍵概念（或者說缺乏線程安全)
  • 上述例子的輸出實際上是無法確定的：
    • 有可能（理論上)“Done”會被列印兩次。
    • 如果交換Go方法里語句的順序，那麼“Done”被列印兩次的幾率會大大增加
    • 因為一個線程可能正在評估if，而另外一個線程在執行WriteLine語句，它還沒來得及把done 設為true。

image.png

鎖定與線程安全簡介

  • 在讀取和寫入共用數據的時候，通過使用一個互斥鎖（ exclusive lock )，就可以修複前面例子的問題。
  • C#使用lock語句來加鎖
  • 當兩個線程同時競爭一個鎖的時候（鎖可以基於任何引用類型對象），一個線程會等待或阻塞，直到鎖變成可用狀態。
  • 在多線程上下文中，以這種方式避免不確定性的代碼就叫做線程安全。
  • Lock 不是線程安全的銀彈，很容易忘記對欄位加鎖，lock也會引起一些問題（死鎖)
internal class Program {
    static bool _done;
    static readonly object _lock = new object();
    
    static void Main(string[] args) {
        new Thread(Do).Start();
        Do();
    }

    static void Do() {
        lock (_lock) {
            if (!_done) {
                Console.WriteLine("Done!");
                Thread.Sleep(100);
                _done = true;
            }
        }
    } 
}

向線程傳遞數據

  • 如果你想往線程的啟動方法里傳遞參數，最簡單的方式是使用lambda表達式，在裡面使用參數調用方法。(例子lambda )
    • 使用Lambda表達式可以很簡單的給Thread傳遞參數。但是線程開始後，可能會不小心修改了被捕獲的變數，這要多加註意。
  • 甚至可以把整個邏輯都放在lambda裡面。(例子multi-lambda )
internal class Program {
    static bool _done;

    static readonly object _lock = new object();
    static void Main(string[] args) {
        new Thread(() => {
            PrintThing("Hello,World!");
        }).Start();

        new Thread(() => {
            Console.WriteLine("Hello World!");
        }).Start();

        //註意C#3.0 之前在Start里傳遞參數，此時thing 的類型必須為object
        new Thread(PrintThing).Start("Hello World!");
    }

    static void PrintThing(object thing) {
        Console.WriteLine("信息：" + thing);
    }
}

異常處理

  • 創建線程時在作用範圍內的 trylcatch/finally塊，線上程開始執行後就與線程無關了。（可以在委托方法里使用try、catch）
  • 在WPF、WinForm里，可以訂閱全局異常處理事件：
    • Application.DispatcherUnhandledException
    • Application.ThreadException
    • 在通過消息迴圈調用的程式的任何部分發生未處理的異常（這相當於應用程式處於活動狀態時在主線程上運行的所有代碼）後，將觸發這些異常。
    • 但是非U線程上的未處理異常，並不會觸發它。
  • 而任何線程有任何未處理的異常都會觸發 AppDomain.CurrentDomain.UnhandledException
internal class Program {
    static bool _done;

    static readonly object _lock = new object();
    static void Main(string[] args) {
        new Thread(DoThrow).Start();
    }

    static void DoThrow() {
        try {
            throw null;
        } catch {
            Console.WriteLine("發生異常");
        }
    }
}

前臺線程 vs 後臺線程

  • 預設情況下，你手動創建的線程就是前臺線程。

  • 只要有前臺線程在運行，那麼應用程式就會一直處於活動狀態。

    • 但是後臺線程卻不行。

  • 一旦所有的前臺線程停止，那麼應用程式就停止了

    • 任何的後臺線程也會突然終止。

  • 註意：線程的前臺、後臺狀態與它的優先順序無關(所分配的執行時間)

  • 可以通過 IsBackground 屬性判斷線程是否是後臺線程。

  • 進程以這種形式終止的時候，後臺線程執行棧中的finally 塊就不會被執行了。

    • 如果想讓它執行，可以在退出程式時使用Join來等待後臺線程（如果是你自己創建的線程)，或者使用signal construct，如果是線程池...

  • 應用程式無法正常退出的一個常見原因是還有活躍的前臺線程。

線程優先順序

  • 線程的優先順序(Thread的Priority屬性）決定了相對於操作系統中其它活躍線程所占的執行時間。
  • 優先順序分為：
    • enum ThreadPriority

提高線程優先順序

  • 提升線程優先順序的時候需特別註意，因為它可能“餓死”其它線程。
  • 如果想讓某線程（Thread)的優先順序比其它進程（Process）中的線程(Thread)高，那就必須提升進程(Process)的優先順序
    • 使用System.Diagnostics下的Process類。
using (Process p = Process.GetCurrentProcess())
p.Priorityclass = ProcessPriorityclass.High;
  • 這可以很好地用於只做少量工作且需要較低延遲的非UI進程。
  • 對於需要大量計算的應用程式（尤其是有UI的應用程式)，提高進程優先順序可能會使其他進程餓死，從而降低整個電腦的速度。

信號 Signaling

  • 有時，你需要讓某線程一直處於等待的狀態，直至接收到其它線程發來的通知。這就叫做signaling(發送信號)。
  • 最簡單的信號結構就是 ManualResetEvent
    • 調用它上面的WaitOne方法會阻塞當前的線程，直到另一個線程通過調用Set方法來開啟信號。
static void Main(string[] args) {
    var signal = new ManualResetEvent(false);

    new Thread(() => {
        Console.WriteLine("等待信號。。。");
        signal.WaitOne();//收到Set()發出的信號之前，停在這裡
        signal.Dispose();
        Console.WriteLine("收到信號。");
    }).Start();

    Thread.Sleep(3000);//這裡等待3s，Main線程再發送信號Set()
    signal.Set();
}
  • 調用完Set之後，信號會於“打開”的狀態。可以通過調用Reset方法將其再次關閉

富客戶端應用程式的線程

  • 在WPF，UWP，WinForm等類型的程式種，如果在主線程執行耗時的操作，就會導致整個程式無響應。因為主線程同時還需要處理消息迴圈，而渲染和滑鼠鍵盤事件處理等工作都是消息迴圈來執行的。

  • 針對這種耗時的操作，一種流行的做法是啟用一個worker 線程。

    • 執行完操作後，再更新到UI

  • 富客戶端應用的線程模型通常是：

    • UI元素和控制項只能從創建它們的線程來進行訪問（通常是主UI線程)
    • 當想從worker線程更新UI的時候，你必須把請求交給UI線程

  • 比較底層的實現是：

    • WPF，在元素的Dispatcher 對象上調用BeginInvoke 或Invoke。
    • WinForm，調用空間的 BeginInvoke 或 Invoke。
    • UWP，調用Dispatcher 對象上的 RunAsync 或Invoke。

  • 所有這些方法都接收一個委托。

  • BeginInvoke或RunAsync通過將委托排隊到U線程的消息隊列來執行工作。

  • Invoke執行相同的操作，但隨後會進行阻塞，直到UI線程讀取並處理消息。

    • 因此，Invoke 允許您從方法中獲取返回值。
    • 如果不需要返回值，BeginInvoke/RunAsync更可取，因為它們不會阻塞調用方，也不會引入能鎖的可能性

示例：
image.png

同步上下文 Synchronization Context

  • 在System.ComponentModel下有一個抽象類：SynchronizationContext，它使得Thread Marshaling得到泛化（把線程的所有權交給另一個線程）。
  • 針對移動、桌面(WPF，UWP，WinForms）等富客戶端應用的API，它們都定義和實例化了SynchronizationContext的子類
    • 可以通過靜態屬性SynchronizationContext.Current來獲得（當運行在UI線程時)
    • 捕獲該屬性讓你可以在稍後的時候從worker線程向UI線程發送數據（例子)
    • 調用Post就相當於調用Dispatcher或 Control上面的 BeginInvoke方法
    • 還有一個Send方法，它等價於Invoke方法

線程池 ThreadPool

  • 當開始一個線程的時候，將花費幾百微秒來組織類似以下的內容：
    • 一個新的局部變數棧（Stack )
  • 線程池就可以節省這種開銷：
    • 通過預先創建一個可迴圈使用線程的池來減少這一開銷。
  • 線程池對於高效的並行編程和細粒度併發是必不可少的
  • 它允許在不被線程啟動的開銷淹沒的情況下運行短期操作

使用線程池線程需要註意的幾點

  • 不可以設置池線程的Name

  • 池線程都是後臺線程

  • 阻塞池線程可使性能降級

  • 你可以自由的更改池線程的優先順序

    • 當它釋放回池的時候優先順序將還原為正常狀態

  • 可以通過 Thread.CurrentThread.IsThreadPoolThread 屬性來判斷是否執行在池線程上

線程池中的整潔

  • 線程池提供了另一個功能，即確保臨時超出計算-Bound的工作不會導致CPU超額訂閱
  • CPU超額訂閱：活躍的線程超過CPU的核數，操作系統就需要對線程進行時間切片
  • 超額訂閱對性能影響很大，時間切片需要昂貴的上下文切換，並且可能使CPU緩存失效，而CPU緩存對於現代處理器的性能至關重要

CLR的策略

  • CLR通過對任務排隊並對其啟動進行節流限制來避免線程池中的超額訂閱。
  • 它首先運行儘可能多的併發任務(只要還有CPU核)，然後通過爬山演算法調整併發級別，併在特定方向上不斷調整工作負載.
    • 如果吞吐量提高，它將繼續朝同一方向(否則將反轉)。
  • 這確保它始終追隨最佳性能曲線，即使面對電腦上競爭的進程活動時也是如此
  • 如果下麵兩點能夠滿足，那麼CLR的策略將發揮出最佳效果：
    • 工作項大多是短時間運行的 (<250毫秒，或者理想情況下<100毫秒)，因此CLR有很多機會進行測量和調整。
    • 大部分時間都被阻塞的工作項不會主宰線程池

image.png

Task

為什麼要使用Task?

Thread的問題

  • 線程(Thread）是用來創建併發(concurrency）的一種低級別工具，它有一些限制，尤其是：
    • 雖然開始線程的時候可以方便的傳入數據，但是當Join 的時候，很難從線程獲得返回值。可能需要設置一些共用欄位。
    • 如果操作拋出異常，捕獲和傳播該異常都很麻煩。
    • 無法告訴線程在結束時開始做另外的工作，你必須進行Join操作（在進程中阻塞當前的線程)
  • 很難使用較小的併發(concurrent)來組建大型的併發。
  • 導致了對手動同步的更大依賴以及隨之而來的問題。

ThreadPool的問題
ThreadPool相比Thread來說具備了很多優勢，但是ThreadPool卻又存在一些使用上的不方便。
比如：

  1. ThreadPool不支持線程的取消、完成、失敗通知等交互性操作；
  2. ThreadPool不支持線程執行的先後次序；

Task看起來像一個Thread，實際上，它是在ThreadPool的基礎上進行的封裝，Task的控制和擴展性很強，線上程的延續、阻塞、取消、超時等方面遠勝於Thread和ThreadPool

Task 簡介

  • Task類可以很好的解決上述問題
  • Task是一個相對高級的抽象:它代表了一個併發操作（concurrent)
    • 該操作可能由Thread支持，或不由Thread支持
  • Task是可組合的(可使用Continuation把它們串成鏈)
    • Tasks 可以使用線程池來減少啟動延遲
    • 使用TaskCompletionSource，Tasks 可以利用回調的方式，在等待/O綁定操作時完全避免線程。

開始一個Task

  • Task類在System.Threading. Tasks命名空間下。
  • 開始一個Task最簡單的辦法就是使用Task.Run (.NET4.5，4.0的時候是Task.Factory.StartNew)這個靜態方法
    • 傳入一個Action委托即可
  • Task 預設使用線程池，也就是後臺線程：
    • 當主線程結束時，你創建的所有tasks都會結束。
  • Task.Run返回一個Task 對象，可以使用它來監視其過程
  • 在Task.Run之後，我們沒有調用Start，因為該方法創建的是“熱”任務(hot task)
    • 可以通過Task 的構造函數創建“冷”任務(cold task)，但是很少這樣做。
  • 可以通過Task的Status屬性來跟蹤task的執行狀態。
Task task=new Task(()=>{
	Console.WriteLine("開啟一個線程");
});
task.Start();

Task.Run(()=>{
	Console.WriteLine("開啟一個線程");
});

TaskFactory factory=new TaskFactory();
factory.StartNew(()=>{
	Console.WriteLine("開啟一個線程");
});

TaskFactory factory2=Task.Factory();
factory2.StartNew(()=>{
	Console.WriteLine("開啟一個線程");
});

等待 Wait

  • 調用task 的Wait方法會進行阻塞直到操作完成
    • 相當於調用thread 上的Join方法
  • Wait也可以讓你指定一個超時時間和一個取消令牌來提前結束等待。

image.png

Long-running tasks長時間運行的任務

  • 預設情況下，CLR線上程池中運行Task，這非常適合短時間運行的Compute-Bound類工作。
  • 針對長時間運行的任務或者阻塞操作（例如前面的例子)，你可以不採用線程池
  • 如果同時運行多個 long-running tasks(尤其是其中有處於阻塞狀態的），那麼性能將會受很大影響，這時有比TaskCreationOptions.LongRunning更好的辦法：
    • 如果任務是IO-Bound，TaskCompletionSource和非同步函數可以讓你用回調(Coninuations）代替線程來實現併發。
    • 如果任務是Compute-Bound，生產者/消費者隊列允許你對任務的併發性進行限流，避免把其他線程和進程餓死。

Task的線程等待和延續

Wait：針對單個Task的實例，可以task1.wait進行線程等待
WaitAny：線程列表中任何一個線程執行完畢即可執行（阻塞主線程）
WaitAll：線程列表中所有線程執行完畢方可執行（阻塞主線程）
WhenAny：與ContinueWith配合,線程列表中任何一個執行完畢，則繼續ContinueWith中的任務（開啟新線程，不阻塞主線程）
WhenAll：與ContinueWith配合,線程列表中所有線程執行完畢，則繼續ContinueWith中的任務（開啟新線程，不阻塞主線程）
ContinueWith：與WhenAny或WhenAll配合使用
ContinueWhenAny：等價於Task的WhenAny+ContinueWith
ContinueWhenAll：等價於Task的WhenAll+ContinueWith

List<Task> taskList = new List<Task>();
TaskFactory factory = Task.Factory;
taskList.Add(factory.StartNew(() => {
    Thread.Sleep(4000);
    MessageBox.Show($"{Task.CurrentId}");
}));
taskList.Add(factory.StartNew(() => {
    Thread.Sleep(6000);
    MessageBox.Show($"{Task.CurrentId}");
})); 
taskList.Add(factory.StartNew(() => {
    Thread.Sleep(8000);
    MessageBox.Show($"{Task.CurrentId}");
}));

Task.WaitAny(taskList.ToArray()); // 1-main-2-3 會阻塞主線程
Task.WaitAll(taskList.ToArray());   // 1-2-3-main 會阻塞主線程

Task.WhenAny(taskList.ToArray()).ContinueWith(t => {
    MessageBox.Show("1個已經執行完");
}); // main-1-"1個已經執行完"-2-3 不會阻塞主線程

Task.WhenAll(taskList.ToArray()).ContinueWith(t => {
    MessageBox.Show("全部已經執行完");
}); // main-1-2-3-"全部已經執行完" 不會阻塞主線程

factory.ContinueWhenAny(taskList.ToArray(), t => {
    MessageBox.Show("1個已經執行完");
}); // main-1-"1個已經執行完"-2-3 不會阻塞主線程  等價於Task的WhenAny+ContinueWith

factory.ContinueWhenAll(taskList.ToArray(), t => {
    MessageBox.Show("全部已經執行完");
}); // main-1-2-3-"全部已經執行完" 不會阻塞主線程   等價於Task的WhenAll+ContinueWith

MessageBox.Show("main");

Task取消

Task中有一個專門的類 CancellationTokenSource 來取消任務執行。

CancellationTokenSource tokenSource=new CancellationTokenSource();  
Task tsk = new Task(() => {
    // IsCancellationRequested預設值 false
    while (!tokenSource.IsCancellationRequested) {
        Thread.Sleep(1000);
        MessageBox.Show("Task想要取消");
    }
});
tsk.Start();
Thread.Sleep(5000);
tokenSource.Cancel(); // 請求取消任務，IsCancellationRequested會變成true
//tokenSource.CancelAfter(5000); // 實現5秒後自動取消任務
// 註冊取消任務觸發的回調函數，即任務被取消時註冊的action會被執行
//tokenSource.Token.Register(() => {
    //MessageBox.Show("Task已經取消");
//});
MessageBox.Show("Task已經取消");
// 1s-Task想要取消-1s-Task想要取消-1s-Task想要取消-1s-Task想要取消-1s-Task想要取消-Task已經取消

Task返回值

  • Task 有一個泛型子類叫做Task，它允許發出一個返回值。
  • 使用Func委托或相容的 Lambda表達式來調用Task.Run就可以得到Task。
  • 隨後，可以通過Result屬性來獲得返回的結果。
    • 如果這個task還沒有完成操作，訪問Result屬性會阻塞該線程直到該task完成操作。
  • Task 可以看作是一種所謂的“未來/許諾”( future、promise)，在它裡面包裹著一個Result，在稍後的時候就會變得可用

image.png

Task異常

  • 與Thread不一樣，Task可以很方便的傳播異常
  • 如果你的task裡面拋出了一個未處理的異常（故障)，那麼該異常就會重新被拋出給：
    • 調用了wait()的地方
    • 訪問了Task的 Result屬性的地方。
  • CLR將異常包裹在AggregateException里，以便在並行編程場景中發揮很好的作用。

image.png

  • 無需重新拋出異常，通過Task的 IsFaulted和 IsCanceled屬性也可以檢測出Task是否發生了故障：
    • 如果兩個屬性都返回false，那麼沒有錯誤發生。
    • 如果IsCanceled為 true，那就說明一個OperationCanceledException為該Task拋出了。
    • 如果lsFaulted為true，那就說明另一個類型的異常被拋出了，而Exception屬性也將指明錯誤。

異常與“自治”的Task

  • 自治的，“設置完就不管了”的Task。就是指不通過調用Wait()方法、Result屬性或continuation進行會合的任務。
  • 針對自治的Task，需要像 Thread 一樣，顯式的處理異常，避免發生“悄無聲息的故障”
  • 自治Task上未處理的異常稱為未觀察到的異常。

未觀察到的異常

  • 可以通過全局的 TaskScheduler.Unobserved TaskException來訂閱未觀察到的異常。
  • 關於什麼是“未觀察到的異常”，有一些細微的差別：
    • 使用超時進行等待的Task，如果在超時後發生故障，那麼它將會產生一個“未觀察到的異常”
    • 在Task發生故障後，如果訪問Task的 Exception屬性，那麼該異常就被認為是“已觀察到的”

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

-Advertisement-
Play Games
更多相關文章
  • Python日期帶時區轉換工具類總結
    @[TOC] # 1.背景 最近項目是國際項目，所以需要經常需要用到UTC時間和local時間的轉換。 所以整理了一下時間戳工具類，方便使用。 這裡主要用到的包就是datatime、time、pytz。 # 2. 遇到的坑 直接看測試案例 ```python tzinfo=pytz.timezone ...
  • 詳談Java中Properties配置類怎麼用
    本文將為大家詳細講解Java中Properties配置類怎麼用，這是我們進行開發時經常用到的知識點，也是大家在學習Java中很重要的一個知識點，更是我們在面試時有可能會問到的問題！文章較長，乾貨滿滿，建議大家收藏慢慢學習。文末有本文重點總結，主頁有全系列文章分享。技術類問題，歡迎大家和我們一起交流討... ...
  • Python工具箱系列(三十四)
    SQLAlchemy是著名的ORM(Object Relational Mapping-對象關係映射)框架。其主要作用是在編程中，把面向對象的概念跟資料庫中表的概念對應起來。對許多語言（例如JAVA/PYTHON）來說就是定義一個對象，並且這個對象對應著一張資料庫的表。而這個對象的實例，就對應著表中... ...
  • Python壓縮JS文件，重點是 slimit
    摘要：Python Web程式員必看系列，學習如何壓縮 JS 代碼。 本文分享自華為雲社區《Python壓縮JS文件，PythonWeb程式員必看系列，重點是 slimit》，作者： 夢想橡皮擦 。 本篇博客將學習壓縮 JS 代碼，首先要學習的模塊是 jsmin。 jsmin 庫 Python 中的 ...
  • 【重學C++】05 | 說透右值引用、移動語義、完美轉發（下）
    ## 文章首發 [【重學C++】05 | 說透右值引用、移動語義、完美轉發（下）](https://mp.weixin.qq.com/s/w7yXp6efE7_V0EHxXWJiJA) ## 引言 大家好，我是只講技術乾貨的會玩code，今天是【重學C++】的第五講，在第四講《[【重學C++】04 ...
  • JavaWeb編程面試題——MyBatis
    面試題==知識點，這裡所記錄的面試題並不針對於面試者，而是將這些面試題作為技能知識點來看待。不以刷題進大廠為目的，而是以學習為目的。這裡的知識點會持續更新，目錄也會隨時進行調整。 ...
  • 在Winform中動態讀寫app.config文件
    在Winform中動態讀寫app.config文件 https://blog.csdn.net/kingmax54212008/article/details/38987277?spm=1001.2101.3001.6650.7&utm_medium=distribute.pc_relevant.n ...
  • Winform中通過自帶的App.config實現從配置文件中讀取配置
    Winform中通過自帶的App.config實現從配置文件中讀取配置 場景 Winform中實現保存配置到文件/項目啟動時從文件中讀取配置(序列化與反序列化對象)： Winform中實現保存配置到文件/項目啟動時從文件中讀取配置(序列化與反序列化對象)_winform 讀取配置文件_霸道流氓氣質的 ...
一周排行
    -Advertisement-
    Play Games
  • C#自增運算符詳解：++i與i++的區別及應用場景
    概述：在C#中，++i和i++都是自增運算符，其中++i先增加值再返回，而i++先返回值再增加。應用場景根據需求選擇，首碼適合先增後用，尾碼適合先用後增。詳細示例提供清晰的代碼演示這兩者的操作時機和實際應用。 在C#中，++i 和 i++ 都是自增運算符，但它們在操作上有細微的差異，主要體現在操作的 ...
  • Taurus.MVC 性能壓力測試（ap 壓測 和 linux 下wrk 壓測）：.NET 版本
    上次發佈了：Taurus.MVC 性能壓力測試（ap 壓測 和 linux 下wrk 壓測）：.NET Core 版本，今天計劃準備壓測一下 .NET 版本，來測試並記錄一下 Taurus.MVC 框架在 .NET 版本的性能，以便後續持續優化改進。 為了方便對比，本文章的電腦環境和測試思路，儘量和... ...
  • 一文讀懂.NET WebAPI中FromRoute、FromQuery、FromBody的關鍵角色與用法
    .NET WebAPI作為一種構建RESTful服務的強大工具，為開發者提供了便捷的方式來定義、處理HTTP請求並返迴響應。在設計API介面時，正確地接收和解析客戶端發送的數據至關重要。.NET WebAPI提供了一系列特性，如[FromRoute]、[FromQuery]和[FromBody]，用 ...
  • WPF/C#實現圖像濾鏡優化方案：打造炫目視覺體驗！
    原因：我之所以想做這個項目，是因為在之前查找關於C#/WPF相關資料時，我發現講解圖像濾鏡的資源非常稀缺。此外，我註意到許多現有的開源庫主要基於CPU進行圖像渲染。這種方式在處理大量圖像時，會導致CPU的渲染負擔過重。因此，我將在下文中介紹如何通過GPU渲染來有效實現圖像的各種濾鏡效果。 生成的效果 ...
  • Bogus 實戰：使用 Bogus 和 EFCore 生成模擬數據和種子數據【完整教程】
    引言 上一章我們介紹了在xUnit單元測試中用xUnit.DependencyInject來使用依賴註入，上一章我們的Sample.Repository倉儲層有一個批量註入的介面沒有做單元測試，今天用這個示例來演示一下如何用Bogus創建模擬數據 ，和 EFCore 的種子數據生成 Bogus 的優 ...
  • WPF隨筆收錄-實時繪製心率曲線
    一、前言 在自己的項目中，涉及到實時心率曲線的繪製，項目上的曲線繪製，一般很難找到能直接用的第三方庫，而且有些還是定製化的功能，所以還是自己繪製比較方便。很多人一聽到自己畫就害怕，感覺很難，今天就分享一個完整的實時心率數據繪製心率曲線圖的例子；之前的博客也分享給DrawingVisual繪製曲線的方 ...
  • wpf程式修改啟動入口註意事項
    如果你在自定義的 Main 方法中直接使用 App 類並啟動應用程式，但發現 App.xaml 中定義的資源沒有被正確載入，那麼問題可能在於如何正確配置 App.xaml 與你的 App 類的交互。 確保 App.xaml 文件中的 x:Class 屬性正確指向你的 App 類。這樣，當你創建 Ap ...
  • 記一次 .NET某爐膛鍋爐檢測系統 崩潰分析
    一：背景 1. 講故事 上個月有個朋友在微信上找到我，說他們的軟體在客戶那邊隔幾天就要崩潰一次，一直都沒有找到原因，讓我幫忙看下怎麼回事，確實工控類的軟體環境複雜難搞，朋友手上有一個崩潰的dump，剛好丟給我來分析一下。 二：WinDbg分析 1. 程式為什麼會崩潰 windbg 有一個厲害之處在於 ...
  • 一個.NET內置依賴註入的小型強化版
    前言 .NET生態中有許多依賴註入容器。在大多數情況下，微軟提供的內置容器在易用性和性能方面都非常優秀。外加ASP.NET Core預設使用內置容器，使用很方便。 但是筆者在使用中一直有一個頭疼的問題：服務工廠無法提供請求的服務類型相關的信息。這在一般情況下並沒有影響，但是內置容器支持註冊開放泛型服 ...
  • WPF隨筆收錄-DataGrid固定右側列
    一、前言 在項目開發過程中，DataGrid是經常使用到的一個數據展示控制項，而通常表格的最後一列是作為操作列存在，比如會有編輯、刪除等功能按鈕。但WPF的原始DataGrid中，預設只支持固定左側列，這跟大家習慣性操作列放最後不符，今天就來介紹一種簡單的方式實現固定右側列。（這裡的實現方式參考的大佬 ...
所有分類