转载

对比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中，多线程编程一般有两种方式：

使用最原生的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/）。