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

原文 

http://mp.weixin.qq.com/s?__biz=MzAwNTMxMzg1MA==&mid=2654077770&idx=7&sn=53564388de2f99590aa6993ee838c97c

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » 对比Java和.NET多线程编程

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址