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
  • 移動開發（一）：使用.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.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類