OpenJDK织机和结构化并发

Project Loom是Hotspot Group赞助的项目之一&＃xff0c;旨在向JAVA世界提供高吞吐量和轻量级的并发模型。 在撰写本文时&＃xff0c;Loom项目仍处于积极开发中&＃xff0c;其API可能会更改。

为什么要织机&＃xff1f;

每个新项目可能会出现的第一个问题是为什么&＃xff1f;
为什么我们需要学习新的东西&＃xff0c;它对我们有帮助&＃xff1f; &＃xff08;如果确实如此&＃xff09;

因此&＃xff0c;要专门针对Loom回答这个问题&＃xff0c;我们首先需要了解JAVA中现有线程系统如何工作的基础知识。

JVM内部产生的每个线程在OS内核空间中都有一个一对一的对应线程&＃xff0c;并具有自己的堆栈&＃xff0c;寄存器&＃xff0c;程序计数器和状态。 每个线程的最大部分可能是堆栈&＃xff0c;堆栈大小以兆字节为单位&＃xff0c;通常在1MB到2MB之间。
因此&＃xff0c;这些类型的线程在启动和运行时方面都很昂贵。 不可能在一台机器上产生1万个线程并期望它能正常工作。

有人可能会问为什么我们甚至需要那么多线程&＃xff1f; 鉴于CPU只有几个超线程。 例如&＃xff0c;CPU Internal Core i9总共有16个线程。
嗯&＃xff0c;CPU并不是您的应用程序使用的唯一资源&＃xff0c;任何没有I / O的软件都只会导致全球变暖&＃xff01;
一旦线程需要I / O&＃xff0c;OS就会尝试为其分配所需的资源&＃xff0c;并同时调度另一个需要CPU的线程。 因此&＃xff0c;我们在应用程序中拥有的线程越多&＃xff0c;我们就越可以并行利用这些资源。

一个非常典型的示例是Web服务器。 每台服务器都能在每个时间点处理数千个打开的连接&＃xff0c;但是同时处理那么多连接要么需要数千个线程&＃xff0c;要么需要异步非阻塞代码&＃xff08; 我可能会在接下来的几周内撰写另一篇文章&＃xff0c;以解释更多有关异步代码 &＃xff09;&＃xff0c;就像前面提到的&＃xff0c;成千上万个OS线程既不是您也不是OS会满意的&＃xff01;

织机如何提供帮助&＃xff1f;

作为Project Loom的一部分&＃xff0c;引入了一种称为Fiber的新型线程。 光纤也称为虚拟线程 &＃xff0c; 绿色线程或用户线程&＃xff0c;因为这些名称暗示完全由VM处理&＃xff0c;并且OS甚至都不知道此类线程存在。 这意味着并非每个VM线程都需要在OS级别具有相应的线程&＃xff01; 虚拟线程可能被I / O阻塞&＃xff0c;或者等待从另一个线程获取信号&＃xff0c;但是&＃xff0c;与此同时&＃xff0c;其他虚拟线程也可以利用基础线程&＃xff01;

上图说明了虚拟线程和OS线程之间的关系。 虚拟线程可以简单地被I / O阻塞&＃xff0c;在这种情况下&＃xff0c;基础线程将被另一个虚拟线程使用。

这些虚拟线程的内存占用量将以千字节为单位&＃xff0c;而不是兆字节。 如果需要&＃xff0c;可以在生成它们之后扩展它们的堆栈&＃xff0c;这样JVM不需要为它们分配大量内存。

因此&＃xff0c;既然我们已经有了一种非常轻巧的方式来实现并发&＃xff0c;我们就可以重新考虑存在于Java经典线程中的最佳实践。

如今&＃xff0c;用于在Java中实现并发的最常用的构造是ExecutorService的不同实现。 它们具有非常方便的API&＃xff0c;并且相对易于使用。 执行程序服务具有一个内部线程池&＃xff0c;用于根据开发人员定义的特征来控制可以产生多少个线程。 该线程池主要用于限制应用程序创建的OS线程的数量&＃xff0c;因为如上所述&＃xff0c;它们是昂贵的资源&＃xff0c;我们应该尽可能地重用它们。 但是现在可以生成轻量级虚拟线程了&＃xff0c;我们也可以重新考虑使用ExecutorServices的方式。

结构化并发

结构化并发是一种编程范式&＃xff0c;是一种编写易于读取和维护的并发程序的结构化方法。 如果代码对并发任务有明确的入口和出口点&＃xff0c;则其主要思想与结构化编程非常相似&＃xff0c;与启动可能比当前作用域持续时间更长的并发任务相比&＃xff0c;对代码的推理要容易得多&＃xff01;

为了更清楚地了解结构化并发代码的外观&＃xff0c;请考虑以下伪代码&＃xff1a;

void notifyUser(User user) { try (var scope &＃61; new ConcurrencyScope()) { scope.submit( () -> notifyByEmail(user)); scope.submit( () -> notifyBySMS(user)); } LOGGER.info( "User has been notified successfully" ); }

notifyUser方法应该通过电子邮件和SMS通知用户&＃xff0c;并且一旦成功完成此方法将记录一条消息。 使用结构化并发&＃xff0c;可以保证在两种通知方法完成后立即写入日志。 换句话说&＃xff0c;如果尝试范围在其中所有已启动的并发作业都完成了&＃xff0c;那么它将完成&＃xff01;

注意&＃xff1a;为了使示例简单&＃xff0c;我们假设notifyByEmail和notifyBySMS在上面的示例中&＃xff0c;在内部确实处理所有可能的极端情况&＃xff0c;并始终使其通过。

JAVA的结构化并发

在本节中&＃xff0c;我将通过一个非常简单的示例展示如何用JAVA编写结构化并发应用程序以及Fibers如何帮助扩展应用程序。

我们要解决的问题

想象一下&＃xff0c;所有I / O绑定有1万个任务&＃xff0c;而每个任务恰好需要100毫秒才能完成。 我们被要求编写高效的代码来完成这些工作。

我们使用下面定义的Job类来模仿我们的工作。

public class Job { public void doIt() { try { Thread.sleep(100l); } catch (InterruptedException e) { e.printStackTrace(); } } }

第一次尝试

在第一次尝试中&＃xff0c;我们使用缓存线程池和OS线程来编写它。

public class ThreadBasedJobRunner implements JobRunner { &＃64;Override public long run(List jobs) { var start &＃61; System.nanoTime(); var executor &＃61; Executors.newCachedThreadPool(); for (Job job : jobs) { executor.submit(job::doIt); } executor.shutdown(); try { executor.awaitTermination( 1 , TimeUnit.DAYS); } catch (InterruptedException e) { e.printStackTrace(); Thread.currentThread().interrupt(); } var end &＃61; System.nanoTime(); long timeSpentInMS &＃61; Util.nanoToMS(end - start);  return timeSpentInMS; } }

在此尝试中&＃xff0c;我们没有应用Loom项目中的任何内容。 只是一个缓存的线程池&＃xff0c;以确保将使用空闲线程&＃xff0c;而不是创建新线程。

让我们看看使用此实现可以运行10,000个作业所需的时间。 我使用下面的代码来查找运行速度最快的10个代码。 为简单起见&＃xff0c;未使用任何微基准测试工具。

public class ThreadSleep { public static void main(String[] args) throws InterruptedException { List timeSpents &＃61; new ArrayList<>( 100 ); var jobs &＃61; IntStream.range( 0 , 10000 ).mapToObj(n -> new Job()).collect(toList()); for ( int c &＃61; 0 ; c <&＃61; 100 ; c&＃43;&＃43;) { var jobRunner &＃61; new var jobRunner &＃61; ThreadBasedJobRunner(); var timeSpent &＃61; jobRunner.run(jobs); timeSpents.add(timeSpent); } Collections.sort(timeSpents); System.out.println( "Top 10 executions took:" ); timeSpents.stream().limit( 10 ) .forEach(timeSpent -> System.out.println( "%s ms" .formatted(timeSpent)) ); } }

我的机器上的结果是&＃xff1a;

执行的前10名&＃xff1a;
694毫秒
695毫秒 696毫秒 696毫秒 696毫秒 697毫秒 699毫秒 700毫秒 700毫秒 700毫秒

到目前为止&＃xff0c;我们有一个代码&＃xff0c;最好情况下大约需要700毫秒才能在我的计算机上运行10,000个作业。 让我们这次使用Loom功能实现JobRunner。

第二次尝试&＃xff08;使用光纤&＃xff09;

在使用Fibers或Virtual Threads的实现中&＃xff0c;我还将以结构化的方式对并发进行编码。

public class FiberBasedJobRunner implements JobRunner { &＃64;Override public long run(List jobs) { var start &＃61; System.nanoTime(); var factory &＃61; Thread.builder().virtual().factory(); try (var executor &＃61; Executors.newUnboundedExecutor(factory)) { for (Job job : jobs) { executor.submit(job::doIt); } } var end &＃61; System.nanoTime(); long timeSpentInMS &＃61; Util.nanoToMS(end - start); return timeSpentInMS; } }

也许关于此实现的第一个值得注意的事情是它的简洁性&＃xff0c;如果将其与ThreadBasedJobRunner进行比较&＃xff0c;您会发现该代码的行数更少&＃xff01; 主要原因是ExecutorService接口中的新更改现在扩展了Autocloseable &＃xff0c;因此&＃xff0c;我们可以在try-with-resources范围中使用它。 所有提交的作业完成后&＃xff0c;将执行try块之后的代码。

这正是我们用来在JAVA中编写结构化并发代码的主要结构。

上面代码中的另一件事是我们可以构建线程工厂的新方法。 Thread类具有一个称为builder的新静态方法&＃xff0c;可用于创建Thread或ThreadFactory 。
此行代码正在创建一个创建虚拟线程的线程工厂。

var factory &＃61; Thread.builder().virtual().factory();

现在&＃xff0c;让我们看看使用此实现可以运行10,000个作业所需的时间。

执行的前10名&＃xff1a;
121毫秒
122毫秒 122毫秒 123毫秒 124毫秒 124毫秒 124毫秒 125毫秒 125毫秒 125毫秒

鉴于Project Loom仍在积极开发中&＃xff0c;仍然有提高速度的空间&＃xff0c;但结果确实很棒。
不论是全部还是部分&＃xff0c;许多应用都可以以最小的努力受益于Fibers&＃xff01; 唯一需要更改的是线程池的线程工厂 &＃xff0c;就是这样&＃xff01;

具体来说&＃xff0c;在此示例中&＃xff0c;应用程序的运行时速度提高了约6倍&＃xff0c;但是&＃xff0c;速度并不是我们在这里实现的唯一目标&＃xff01;

尽管我不想写有关使用Fibers大大减少了的应用程序的内存占用的信息&＃xff0c;但是我强烈建议您在这里浏览本文的代码&＃xff0c;并比较使用的内存量和每个实现占用的OS线程数&＃xff01; 您可以在此处下载Loom的官方早期试用版。

在接下来的文章中&＃xff0c;我将详细介绍Loom引入的其他API项目&＃xff0c;以及我们如何将其应用于现实生活中的用例。

请不要犹豫&＃xff0c;通过评论与我分享您的反馈意见

翻译自: https://www.javacodegeeks.com/2020/02/openjdk-loom-and-structured-concurrency.html