對比Java和.NET多線程編程

這篇文章以對比的方式總結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中，多線程編程通常有兩種方式：

1.使用最原生的API

2.使用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?