专栏首页天马行空布鲁斯对比Java和.NET多线程编程

对比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);其实理解这两个概念,我们可以分别类比下面会提到的BlockingQueueCompletionService

Java

在java中,多线程编程一般有两种方式:

  1. 使用最原生的API
  2. 使用concurrent包提供的API

1. 使用最原生的API

启动一个线程有两种方式:继承java.lang.Thread类和实现java.lang.Runnable接口。这两个类都是从java 1.0就开始有了。

线程之间同步主要是用synchronized关键字和java.lang.Objectwait()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,调用Futureget()方法可以获取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关键字的作用一样。当然,使用Locksynchronized关键字还是有一些区别的:比如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/)。

本文分享自微信公众号 - 天马行空布鲁斯(gh_2feda5c053bd),作者:huazailmh

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2020-02-22

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 浅析SAP Subscription Billing可扩展性

    SAP Subscription Billing是SAP推出的用于订阅关系(Subscription)管理的一款SaaS产品。通常来说,任意一个标准产品都不可能...

    Bruce Li
  • 浅析Tomcat高并发之连接池、线程池

    记得大学的《网络工程》有一个课后作业:用Java实现一个web服务器,当时想的是为了提高吞吐量,可以用多线程实现,即对于每一个客户端请求连接,都启动一个线程来处...

    Bruce Li
  • 关于文本排序的那些事

    大家都知道,排序算法是计算机学科最基础的知识之一,常见的排序算法有冒泡、快排等。这里讨论的文本排序不是一个排序算法,而是作为某个排序算法的底层依赖,常常在多语言...

    Bruce Li
  • 【问题解决】Mono下部署ASP.NET应用提示:System.IO.FileNotFoundException

    也就是站点启动时找不到站点根目录bin文件夹中的roslyn编译器 由于Mono不兼容roslyn那我们只能考虑改用msbuild 一个项目的编译信息是由.cs...

    KenTalk
  • Windows Workflow Foundation 中的跟踪服务

          Windows Workflow Foundation 中最强大的功能之一是跟踪。它使您能够监控事件、活动属性以及您的工作流中的自定义数据。在本专栏...

    张善友
  • .Net下收发邮件第三方公共库

    http://www.lumisoft.ee/lswww/download/downloads/Net/

    跟着阿笨一起玩NET
  • 聊聊前端项目

    做前端也不是很久,也没做过什么特别大型或者是特别复杂需要很多前端配合开发的项目,所以对于前端的架构我并没有一个清晰的认识。只是最近看着新公司的项目,实在有感而发...

    wade
  • 告诉你一个 AtomicInteger 的惊天大秘密!

    在 JDK1.5 之前,为了确保在多线程下对某基本数据类型或者引用数据类型运算的原子性,必须依赖于外部关键字 synchronized,但是这种情况在 JDK1...

    cxuan
  • 6 大主流 Web 框架优缺点对比:15篇前端热文回看

    本文精选了「前端大全」2017 年 12 月的 15 篇热门文章。其中有职场分享、技术分享和技术资源。 《6 大主流 Web 框架优缺点对比》 是该读些评论和做...

    企鹅号小编
  • delete操作对UNDO表空间容量的冲击

    对于回滚事务,他保存的是修改值的前镜像,注意,不是修改的数据块,或者整行记录的镜像。

    bisal

扫码关注云+社区

领取腾讯云代金券