這篇文章以對比的方式總結Java和.NET多線程編程。

基本概念

多線程：很多開發語言都提供多線程編程支持，比如Java，C#。

并發（concurrent）：即使對于單核CPU，我們也會采用多線程等技術提高service的并發處理能力，我們經常說的高并發，就是這個意思。

并行（parallel）：多個計算機任務能夠真正在同一時刻同時執行，狹義的講，對同一臺計算機，在單核CPU時代，理論上，這是不可能的；隨著計算機得硬件得發展，多核CPU使得這個成為了可能。

異步（asynchronous programming）：異步編程可以基于多線程（語言層面提供的多線程），并不是一定要基于多線程，比如說nodejs，nodejs的異步編程其實是基于事件驅動和事件循環來實現的。

阻塞（blocking）/非阻塞（non-blocking）：這兩個概念更多是出現在IO的場景，比如Blocking IO（BIO）和Non-blocking IO（NIO）；其實理解這兩個概念，我們可以分別類比下面會提到的BlockingQueue和CompletionService。

Java

在java中，多線程編程一般有兩種方式：

使用最原生的API

使用concurrent包提供的API

1. 使用最原生的API

啟動一個線程有兩種方式：繼承java.lang.Thread類和實現java.lang.Runnable接口。這兩個類都是從java 1.0就開始有了。

線程之間同步主要是用synchronized關鍵字和java.lang.Object的wait()、notify()方法。

2. 使用concurrent包提供的API

其實，concurrent包提供很多功能，比如線程池相關類、阻塞隊列、集合的線程安全實現等，具體可以參考concurent包的官方文檔（https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/package-summary.html）。

這里列舉一些用過的concurrent包下API的典型例子：

1) 啟動一個線程池，把要做的事情放到java.util.concurrent.Callable接口里面實現(Callable不同于Runnable接口的地方是，Callable可以有返回)，然后把Callable實現類提交給線程池管理，同時可以得到一個java.util.concurrent.Future，調用Future的get()方法可以獲取Callable返回結果。

ExecutorService threadPool = Executors.newFixedThreadPool(10);List<Future<String>> futureList = new ArrayList<Future<String>>)(); for(int i = 0; i < 100; i++) {Future<String> future = threadPool.submit(new TaskCallable());futureList.add(future); }for(Future<String> future : futureList) {System.out.println(future.get()); }threadPool.shutdown();

如果有100個Task要執行，可以使用java.util.concurrent.CountDownLatch類來等待所有Task都執行完才做下一步操作。

2) 上面示例代碼中future.get()是一個阻塞動作，如果有100個Task，有可能后面的Task先執行完，這樣對后面Task結果的處理就會一直pending在前面Task的future.get()調用上。concurrent包提供了另外一個API - CompletionService，可以解決這個問題。實例代碼如下：

ExecutorService threadPool = Executors.newFixedThreadPool(10);CompletionService<String> completionService = new ExecutorCompletionService<String>(threadPool);for(int i = 0; i < 100; i++) {Future<String>?future?=?completionService.submit(new?TaskCallable()); }for(int i = 0; i < 100; i++) {String result = completionService.take().get();System.out.println(result); }threadPool.shutdown();

3) 控制兩個線程執行順序，一個線程等另外一個執行完之后才能繼續執行，可以用java.util.concurrent.SynchronousQueue比較容易實現；而傳統的做法則是采用wait/notify。其實SynchronousQueue實現了java.util.concurrent.BlockingQueue接口，這個接口還有一些其它的實現類，比如：java.util.concurrent.ArrayBlockingQueue，當我們需要實現一個典型的生產者消費者模型時，就可以直接使用這個類。

4） HashMap的線程安全實現java.util.concurrent.ConcurrentHashMap。關于ConcurrentHashMap的實現原理，可以參考這篇文章（漫畫：什么是ConcurrentHashMap？）。

5) 還有一個經常用到的就是concurrent包下面的java.util.concurrent.locks.Lock接口，這個接口有一個實現類java.util.concurrent.locks.ReentrantLock，這是一個可重入鎖的實現，和上面提到的synchronized關鍵字的作用一樣。當然，使用Lock和synchronized關鍵字還是有一些區別的：比如Lock可以實現公平鎖，synchronized則只能是非公平鎖。

6) java.util.concurrent.atomic包下面提供的原子操作類，也經常用到。當我們要實現自增長功能時，可以使用java.util.concurrent.atomic.AtomicInteger類，這個類實現自增長原子操作的原理是CAS（Compare And Set）算法，而不是加鎖的方式，所以在某些情況下可能會效率高一些。關于CAS算法的原理，可以參考這篇文章（庫存扣多了，到底怎么整 | 架構師之路）。

C# /?.NET

對比Java里面的多線程編程實現方法，.NET里面基本上也都有對用的實現。

1) Java中的Thread類和Runnable接口；對應.NET里面就是System.Threading.Thread類和System.Threading.ThreadStart委托。

2) Java中線程同步主要用synchronized關鍵字；而.NET中則用lock關鍵字，但是lock關鍵字不能應用到方法上，如果要把同步加到方法上，可以用System.Runtime.Remoting.Context.Synchronization特性。

3) 除了上面提到的語言層面提供的關鍵字可以用于加鎖，Java的concurrent包提供了Lock類；對應.NET就是System.Threading.Monitor類。

4) Java的concurrent包提供了一些原子操作的類，比如java.util.concurrent.atomic.AtomicInteger；對應.NET里面就是System.Threading.Interlocked。

5) Java的concurrent包提供了一些集合的線程安全實現，比如java.util.concurrent.ConcurrentHashMap；在.NET里面也是類似，.NET里面的System.Collections.Concurrent這個namespace下，也提供了很多集合的線程安全實現，比如System.Collections.Concurrent.ConcurrentDictionary。

6) .NET里面使用線程池實現多線程編程例子如下（See https://docs.microsoft.com/en-us/dotnet/api/system.threading.threadpool?view=netcore-3.1）：

using System; using?System.Threading;public class Example {public static void Main() {// Queue the task.ThreadPool.QueueUserWorkItem(ThreadProc);Console.WriteLine("Main thread does some work, then sleeps.");Thread.Sleep(1000);Console.WriteLine("Main thread exits.");}// This thread procedure performs the task.static void ThreadProc(Object stateInfo) {// No state object was passed to QueueUserWorkItem, so stateInfo is null.Console.WriteLine("Hello from the thread pool.");} }

7) .net 4.0新增的TAP（task-based asynchronous pattern），不需要顯示操作線程（CLR負責管理線程的分配），只需要關注Task，如下：

using System; using System.Threading; using System.Threading.Tasks;namespace ConsoleApp1 {class Program2{static void Main(string[] args){Console.WriteLine("current thread: " + Thread.CurrentThread.ManagedThreadId);// Construct a started task using Task.Run.String taskData = "delta";Task t3 = Task.Run(() => {Console.WriteLine("Task={0}, obj={1}, Thread={2}", Task.CurrentId, taskData, Thread.CurrentThread.ManagedThreadId);Thread.Sleep(1000 * 10000);});// Wait for the task to finish.//t3.Wait();Task t2 = Task.Run(() => {Console.WriteLine("Task={0}, obj={1}, Thread={2}", Task.CurrentId, taskData, Thread.CurrentThread.ManagedThreadId);});// Wait for the task to finish.t2.Wait();Console.WriteLine("end");}} }

在.net 4.5之后，又新增了async/await關鍵字，這種方式基于TAP，通過這種方式可以方便的實現Task完成之后的callback邏輯，比如上面例子中想在t3執行完了之后再做一些邏輯，需要調用t3.wait()，或者調用Task.WaitAll()方法。有async/await關鍵字之后，可以很方便的實現，如下：

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks;namespace ConsoleApp1 {class Program{static void Main(string[] args){TestMain();}static void TestMain(){Console.Out.Write("Start\n");GetValueAsync();Console.Out.Write("End\n");Console.ReadKey();}static async Task GetValueAsync(){await Task.Run(()=>{Thread.Sleep(1000);for(int i = 0; i < 5; ++i){Console.Out.WriteLine(String.Format("From task : {0}", i));}});Console.Out.WriteLine("Task End");}} }

上面Console.Out.WriteLine("Task End");這行代碼即是Task執行完成之后才執行的邏輯。這個有點像javascript里面的Promise.

8) .net 4.0里面還提供了并行編程的一些功能，比如：System.Threading.Tasks.Parallel。所謂并行編程，狹義的講，就是說可以充分利用現在計算機CPU多核的優勢，讓運算任務在多個核上同時并行執行。更多的，可以參考（https://docs.microsoft.com/en-us/dotnet/standard/parallel-programming/）。

相關閱讀

• 從Java轉向.NET/C#，Are You OK?

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的对比Java和.NET多线程编程的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。