SOFTWARE: PRACTICE AND EXPERIENCE

Softw. Pract. Exper. 2016; 46:685–708

Published online 6 May 2015 in Wiley Online Library (wileyonlinelibrary.com). DOI: 10.1002/spe.2330

RJ: a Java package providing JR-like concurrent programming

Ronald A. Olsson*^,dagger; and Todd Williamson

Department of Computer Science, University of California, Davis, One Shields Avenue, Davis, CA 95616-8562, USA

SUMMARY

The JR concurrent programming language extends Java with a richer concurrency model, by adding several new types and statements. JR provides dynamic remote virtual machine creation, dynamic remote object creation, remote method invocation, dynamic process creation, rendezvous, asynchronous message passing, semaphores, concurrent invocation, and shared variables. This paper presents RJ, a package for Java that provides JR-like features. The paper gives an overview of RJ and its key features; describes the implications of RJrsquo;s design, including how RJ provides additional, useful flexibility; discusses the implementation of RJ; and gives qualitative and quantitative evaluations of our work with respect to feasibility and usability, experimentation, migration, and performance. RJ has been successful in meeting these goals and in providing insight into the trade-offs between using a concurrent programming language versus using the equivalent concurrent package. Our work has yielded a few surprises in dealing with some concurrent programming language features, in understanding the run-time performances of JR versus RJ programs, and in obtaining some additional, useful flexibility for concurrent programming applications. Copyright copy; 2015 John Wiley amp; Sons, Ltd.

Received 29 October 2014; Revised 8 April 2015; Accepted 20 April 2015

KEY WORDS: concurrency; concurrent programming languages; concurrent programming packages; package design; package implementation; JR programming language

INTRODUCTION

The JR concurrent programming language extends Java with a richer concurrency model [1, 2], which is based on that of SR [3, 4]. JR provides dynamic remote virtual machine creation, dynamic remote object creation, remote method invocation, dynamic process creation, rendezvous, asynchronous message passing, semaphores, concurrent invocation, and shared variables. These language features are provided by adding several new types and statements to the Java language.

The JR implementation [2, 5] consists of a compiler and a run-time system, and extends the Java implementation. The JR compiler extends the Java compiler by translating JR language features to Java code. The JR run-time system provides a JRVM, which extends the Java Virtual Machine.

RJ [6] is a Java package that provides JR-like concurrent programming features. We have several motivations and goals for developing the RJ package:

Feasibility and usability: We wanted to see how feasible it is to implement fairly complicated language features within a package. Along with that, we wanted to see whether the resulting package would be usable: whether programs using it would be readable and easy to develop.

Experimentation: We were hopeful that having a package would allow for easier experimentation with concurrent programming features and their implementations.

*Correspondence to: Ronald A. Olsson, Department of Computer Science, University of California, Davis, One Shields Avenue, Davis, CA 95616-8562, USA.

^dagger;E-mail: olsson@cs.ucdavis.edu

Migration: We were hopeful that having a package would make it simpler to migrate the RJ package as newer versions of the base language (Java) become available than it has been to migrate the JR language implementation.

Performance: We were interested to see what effect using a package would have on performance.

RJ has been successful in meeting our goals and in providing insight into the trade-offs between using a concurrent programming language versus using the equivalent concurrent package. The design and implementation of RJ has in some ways been straightforward, although deciding upon the exact interfaces to get the lsquo;right feelrsquo; has required some iteration. Moreover, our work has yielded a few surprises. This paper will describe these in more detail later (Sections 2 and 3), but here is a preview.

Some of JR primitives involve blocks of code. We were able to provide similar mechanisms in RJ, but we had to deal with issues of control flow and accessing local variables.

In many cases, the performance of equivalent JR and RJ programs are about the same; that is expected as both ultimately use the same run-time system.

However, in some cases, the performances differ. As one would expect, the JR compiler can perform some optimizations that cannot be performed when using the RJ package. But, in one case, the RJ implementation is able to perform an optimization that the JR implementation cannot provide.

The design of the RJ package allows some additional, useful flexibility for concurrent programming applications.

The RJ is related to PySy [7, 8], a Python package that provides JR-like synchronization. We developed RJ and PySy concurrently, and each influenced the other. While some of the motivations behind RJ and PySy are the same, some of our design decisions differ and the overall packages differ so as to fit better with their different base languages. This paper addresses several design issues not described in the PySy paper. Also, we are able to provide more direct performance comparisons, RJ versus JR, than we were in our PySy work.

The RJ is also related to other packages that provide enhanced concurrency for Java programs. For example, the Java concurrent programming package [9] and Javarsquo;s java.util.concurrent.BlockingQueue package provide various forms of synchrono

剩余内容已隐藏，支付完成后下载完整资料

---

摘要

JR并发编程语言扩展与丰富的java并发模型，通过添加和报表的几种新类型。JR提供动态的远程虚拟机的创建、动态的远程对象的创建，远程方法调用，动态的创作过程，交会，异步消息传递、信号量、并发调用，共享变量。本文介绍了RJ，用java提供JR之类的功能包。本文给出了RJ及其关键功能的概述；介绍了该设计的启示，包括如何RJ提供额外的，有用的灵活性；论述了RJ的实施；并给出了定性方面的可行性和实用性，实验，迁移，我们的工作评估和绩效定量。RJ已经满足这些的目标，并提供洞察取舍之间使用并行编程语言和使用等效并行包成功。我们的工作已经在处理一些并行编程语言的特点产生了一些惊喜，在了解JR与RJ程序的运行时性能，并获得了一些额外的，并行编程应用有用的灵活性。copy;版权2015约翰威利父子公司

关键词：并发；并发程序设计语言；并行编程包装；包装设计；包装实施；JR编程语言

1．简介

JR并发编程语言java扩展更丰富的并发模型[ 1，2 ]，这是基于SR [ 3，4 ]。JR提供动态的远程虚拟机的创建、动态的远程对象的创建，远程方法调用，动态的创作过程，交会，异步消息传递、信号量、并发调用，共享变量。通过添加和陈述一些新类型的java语言提供了这些语言特点。

JR实现[ 2，5 ]由编译器和运行时系统，并扩展了java实现。JR JR编译器翻译语言功能的java代码扩展java编译器。JR的运行时系统提供了一个jrvm，它扩展了java虚拟机。

RJ [ 6 ]是一个java包，提供小如并发编程。我们已经开发的RJ包几个动机和目标：

.可行性和可用性：我们希望看到在一个包中实现相当复杂的语言特性是多么的可行。随着这一点，我们想看看是否产生的包将是可用的：是否使用它的程序将是可读的，易于开发。

.实验：我们希望有一个包将允许更容易的并发编程功能及其实现的实验。

.迁移：我们希望有一个包将使它更简单的迁移RJ包作为新版本的基础语言（java）成为可比它已经移居JR语言实现。

.性能：我们感兴趣的是使用包对性能有什么影响。

RJ已经达到了我们的目的和洞察的权衡使用并行编程语言和使用等效并行包之间是成功的。 RJ的设计与实现，在某些方面很简单，虽然决定确切的接口来获得正确的感觉需要一些迭代。此外，我们的工作取得了一些惊喜。本文将详细描述这些以后（第2和第3节），但这里是一个预览。

.一些JR原语包括代码块。我们能够在RJ提供类似的机制，但是我们不得不面对的问题，控制流和局部变量的访问。

.在许多情况下，等效JR和RJ程序的性能是相同的；这将最终都使用同一个运行时系统。

然而，在某些情况下，性能不同。正如预期的那样，JR编译器可以进行一些优化，采用RJ包时，无法执行。但是，在一个案例中，RJ的实施能够进行优化，JR实现不能提供。

.对RJ包装设计允许一些额外的并行编程应用有用的灵活性。

RJ是PySy [ 7，8 ]，一个Python包提供JR像同步。我们开发了RJ和PySy兼任，并在影响其他。虽然一些RJ 和PySy背后的动机是一样的，我们的一些设计决策不同，在所有的包装不同，从而更好适应与他们的不同的基础语言。本文涉及的几个设计问题在PySy论文中描述。另外，我们可以提供更直接的性能比较，RJ与JR，比我们在PySy中的工作。

RJ也是其他包，java程序提供增强的并发。例如，java并发编程包[ 9 ]和java的 java.util.concurrent.BlockingQueue包，提供各种形式的同步和异步消息传递。RJ的特定组合的基元，虽然，有些更富的原因，正如前面提到的，它反映了那些在JR语言和RJ仍然提供相同的高层次的抽象JR（例如，操作，后期定义）。我们的工作是在[ 10 ]有关的工作，其中比较权衡使用与使用java.util.concurrent语言的方法（Habanero-Java）。我们的工作有一个不同的重点：比较库的方法与语言的方法，都提供相同的抽象。

本文的其余部分组织如下。2节介绍了RJ及其关键功能概述。3节介绍了RJ的设计的影响，包括RJ提供额外的，有用的灵活性。4节讨论RJ的实施。第5节给出了定性和定量评价我们的工作，相对于本节早些时候给出的目标。最后，第6节总结并提出了一些未来的工作。

2。概述和主要特征

在本节中，我们概述了RJ的关键特征。因为RJ是基于JR的编程语言，我们fiRST给JR的概述，然后RJ概述。说明的主要特点，给出了一个小程序，相当于RJ程序实例。然后我们讨论如何实现额外的JR在RJ。

这部分的零件，包括JR的代码示例，基于[ 2 ]的介绍和实例，其中包含小进一步讨论细节。

2.1。概述JR

JR扩展java与更丰富的并发模型[ 2，5 ]，即基于SR [ 3，4 ]。JR提供动态的远程虚拟机的创建、动态的远程对象的创建，远程方法调用，动态的创作过程，交会，异步消息传递，信号量，共享变量。JR提供上述的同步机制通过业务和能力。

分布式应用程序中，JR是由一组虚拟机（VM）。每个VM代表一个地址空间，程序或单元的分布，和包含几个过程，可以共享变量的地址空间或通过短信上的其他进程，VM或过程对其他虚拟机。Dagger;VMS可以位于一个单独的物理机或在多个物理机的网络连接。通常情况下，虚拟机的数量不是很大，但它随程序执行。小程序开始执行的主要方法，它是位于主虚拟机。它创建其他虚拟机VM和创建远程对象。这些远程对象通过远程对象引用在程序内引用。虚拟机之间的通信是透明的。

JR的操作抽象概括的方法。像一个方法，它有一个名字，可以传递参数和返回结果。像一个方法声明，声明的具体操作指定的操作，即签名、返回类型和参数类型。不同的手术方法，可调用两种方式和服务的方式有两种，其在解决并行编程问题提供了灵活性。更具体地，操作可同步通过CALL语句调用（call）或异步方式发送报表的手段（send）。一个操作可以通过一个方法或通过输入报表服务（inni）。这将产生以下四个组合：

在这些调用，调用程序和服务器可以在不同的虚拟机。

JR的inni语句允许多方式的选择性接受。一个inni可以等待一个操作的调用；每个执行服务调用。一个inni由一个或更多的武器。每个臂的指定具体的操作和一个代码块中调用执行，操作维修。总的来说，inni最古老的服务等待调用；然而，这种行为是可以改变的描述。

多个进程可以在不同的inni语句相同的操作服务。控制通过竞争过程访问调用，还提供了一定程度的公平性，JR定义等价类操作[ 1，11 ]。短暂地，放到同一个等价类，如果他们出现在同inni的操作。

一个inni的手臂也可以包含一个同步表达（storlsquo;suchthatclausersquo;）和调度的表达（by or lsquo;by clausersquo;）。同步表达特定的定义的布尔条件决定是否操作调用应该是服务，即无论是可选的。调度定义表达特定的顺序来调用服务选择。原始类型或可比较类型的表达式将对每个调用进行求值；其值称为调用级别。用最小的等级选择调用一个优先级服务。

一个inni的手臂也可以指定一个定量，可以用来表示一个操作数在数组或数组的操作能力（后期定义）。定量包含一个范围，比如i：= 1 N（不使用JR的语法），并可能包含一个选择标准，如i：= 1 N，F（i）gt; 0。

JR提供的能力，作为（第一级）的引用或指针操作的并发程序，来连接不同的参与者的计算。一个特定的操作能力定义的签名的声明可以参考。

JR有两个恒定的能力值：null和noop。调用或服务其值为null的功能会导致错误。调用能力，其价值是noop无影响。服务能力，其值为noop操作是允许的，但服务器只是块因为没有这样的调用。

JR允许几个缩写为业务和能力的常见用途：

.JR的过程简称表示一个单独的线程的执行是自动启动。它实际上代表了一个操作，由一个方法和隐式发送调用服务。

.JR的接收语句是一个简单的缩写，对inni常见的形式。areceive允许接收从一个操作没有返回值。

.JR的信号量是一个简单的操作形式的缩写。随着SEM宣布信号，熟悉的P（相当于一个接收）和V（相当于送）可以使用。

JR还提供了一种声明回复和提出声明的形式，分别为早期和延期答复12–[ 16 ]。这些陈述适用于调用被封闭或封闭因尼声明服务操作方法。早期的回复是有用的，例如，当服务器计算调用的返回值但有额外的活动，它仍然需要执行，调用相关的例如，服务器需要关闭一个写日志信息。正是有用的当服务器部分服务的调用和想通过剩余的工作，应对调用另一个过程的责任。例如，一个经理可能提出过程调用一个工人池中的许多工人。

最后，JR提供并发的调用语句（CO）。它具体定义一组操作调用和正常终止时，所有调用已经完成。公司还允许你定义处理相关业务组和后处理的代码（PPC），每次调用完成后执行。该合作是有用的应用程序，需要集体通信，如发起组的并发计算，读/写分布式数据库，分布式投票计划。

2.2。概述RJ

因为RJ是一个软件包，它提供了JR喜欢用纯java语言的并发功能特点。RJ define等几种类；例如，它提供了一个虚拟机VM类。在JR延伸一些新的语句和表达式java，RJ提供等效的方法，该代码调用功能。对于简单的陈述（例如，接收）和短语，调用的方法也很简单。对于更复杂的语句（如inni），调用的方法很简单，但参与调用的对象是有点复杂。更具体地定义，RJ用户代码需要建立等价的语句块，把这些拼凑成一个对象形成整体等效，然后调用方法的对象。

RJ需要更多的抽象是对用户可见。例如，它要求用户在调用对象中放置每个调用的参数。此对象还拥有返回值。（见第3.2条作进一步讨论。）

RJ也暴露出作业层次的用户。图1显示了简化fiED类层次的操作在RJ。如图所示，RJ的方式有两种实施手术（opimpl）：opmethod和opinni。该用户申报和创建这两种类型的对象。出现相同的层次

Figure 1. Simplified class hierarchy for operations in RJ.(Notation: lsquo; rsquo; means public; italics indicate an abstract class or method.)

Figure 2. JRrsquo;s dining philosopherrsquo;s main.jr.

Figure 3. RJrsquo;s dining philosopherrsquo;s main.java.

从概念上讲在JR [ 1 ]和JR的实现，但它是不可见的用户。操作的完整的结构类似于RJ JR的，但它被按照[ 17 ]，因此它可以使用智能代理的设计（即，使用缓存来消除一些RMI调用）。完整的层次结构提供了一个OpProxy，这是JR能力RJ是等效的，对用户是可见的。

2.3。举例说明关键RJ特征

说明关键RJ的特点，提出了等效JR和RJ解与经典的哲学家进餐问题[ 18 ]比较。在这个问题上，每个哲学家反复从事饮食，然后思考。一个哲学家可以吃当邻国在吃也没有。我们的解决方案采用一个单一的，集中的仆人的过程，其目的是确保约束。从概念上讲，每个哲学家请求许可，吃，吃，然后表明它已经完成吃。然而，在这里，请求被建模为一个单一的请求为两个叉和释放被建模为一个单一的释放的两个叉保持与其他解决方案的结构，在这个问题中，个别福克斯分别要求[ 2 ]。

我们的解决方案采用三类：主，哲学家和仆人。这些类还阐明关键的JR和RJ的特点。对于每个类，表现在以下优先描述代码是如何工作的，然后比较JR和RJ代码。

2.3.1.主程序：虚拟机和远程对象

2.3.1.1。描述。图2和图3显示的主要类，在执行开始。它优先读取命令行参数指定的哲学家的数量（N）和“会话”的数量每个哲学家是执行（T）。主然后创建一个实例的仆人和N实例哲学家。仆人是在主VM上创建的，哲学家们在主机数组中的物理机器的集合上分布得比较均匀。仆人的例子是通过哲学家的数量。哲学家的每一个实例都被传递给仆人的实例、哲学家的身份和会话的次数。

2.3.1.2。比较。JR代码创建实例的仆人和哲学家使用远程关键词而RJ代码调用Create.createInstance() 方法。JR的代码还使用远程关键词作为远程对象的类型的一部分；RJ代码使用remoterefs类，类型是用于同样的目的：允许访问远程对象的操作中，在哲学家的代码后见（图4和图5）。类似于远程对象的创建，JR代码使用新的vm()上创建新的虚拟机hellip;而该代码调用Create.createInstance()方法。

注意小代码使用类的名字在其远程对象创建而RJ代码使用String类的名称作为Create.createInstance()的参数。因为编译器会处理小类名称的使用小方法是可能的。RJ代码

Figure 4. JRrsquo;s dining philosopherrsquo;s philosopher.jr.

Figure 5. RJrsquo;s dining philosopherrsquo;s philosopher.java.

不能直接使用类名因为本身，一个类的名字在java代码没有意义。sect;不幸的是，这种使用字符串更容易出错。

一个小的区别是，RJ远程对象的创建必须在try块因为它可以抛出一个异常（从RMI）。同样是真实的红外遥控对象的创建，但JR编译生成所需的try块的代码中生成的。

2.3.2。哲学家：调用操作。

2.3.2.1。描述。图4和图5显示了哲学家的代码。每个哲学家轮流吃饭和思考。在吃之前，哲学家叫仆人的getforks操作；进食后，它将以仆人的relforks

剩余内容已隐藏，支付完成后下载完整资料

---

资料编号：[137052]，资料为PDF文档或Word文档，PDF文档可免费转换为Word