对比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?