Linda implementations in Java for concurrent systems

Parallel and distributed computing techniques are used to solve computing problems that cannot be solved using one computer. Java -one of the most widely used programming languages -has built in support for distributed computing via a Sockets library, Remote Method Invocation (RMI), etc. Java also has built in support for concurrent programming via a Threads library, but has no built-in support for parallel programming. If a library were available which enabled parallel programming through a model which as much semantic similarity to the existing Threads library, it would be considerably easier for Java programmers to adopt parallel programming. Furthermore such a library would have greater value if it were a user-level library -requiring no modifications to underlying VM -and capable of functioning with any compatible Java Virtual Machine.

1999

While Java has provided a mechanism for concurrent programming implemented as language constructs, it is too rudimentary for most programmers and has certain limitations that make programs unnecessarily complex and prevent fine-grained concurrency.

… 2000: WoTUG-23: …, 2000

Java provides support for concurrent and parallel programming through threads, monitors and its socket and Remote Method Invocation (RMI) classes. However, there have been many concerns expressed about the way in which this support is provided, e.g., [1][2], citing problems such as improper implementation of monitors and difficulty of programming with threads. Hoare's Communicating Sequential Processes (CSP) [3][4][5] model fully specifies thread synchronization and is based on processes, compositions, and channel communication. It provides a mathematical notation for describing patterns of communication using algebraic expressions and contains formal proofs for analyzing, verifying and eliminating undesirable conditions, such as race hazards, deadlocks, livelock, and starvation. Two independent research efforts provide a CSP based process-oriented design pattern for concurrency implemented in Java: Communicating Sequential Processes for Java (JCSP) [6] and Communication Threads in Java (CTJ) [7]. In this paper, we compare these two packages, looking at the philosophy behind their development, their similarities, their differences, their performance, and their use.

Islamic University Multidisciplinary Journal (IUMJ), 2020

Nowadays, there has been an increasing demand for high-speed computation, parallel processing, and efficient algorithms to efficiently manage the rapid increase in the volume of data which gave rise to much research being carried out in concurrent applications and mechanisms to improve performances. In this paper, two parallel concurrency frameworks were developed and tested using the quick-sorting algorithm on a multiprocessor machine to compare their performances. System.nanoTime() method was used for benchmarking the two frameworks. The results show that the ServExecSort framework performs better than NaïveParallelSort on a larger array size while the NaïveParallelSortr exhibits better performance on smaller array elements. It is therefore concluded that a framework that uses separate thread pool and future to keep track of submitted tasks exhibits better performances than a framework that creates separate threads for each task which leads to large overheads and performance degradation.

Multicore platforms allow developers to optimize applications by intelligent partitioning different workloads on different processor cores. Currently, application programs are optimized to use multiple processor resources, resulting in faster application performance. Our earlier research work focused native thread for Java on windows thread, Pthread, Intel TBB, respectively, we developed NativeThreads, NativePthread, Java Native Intel TBB beneath windows 32-bit platform. This article aims to identify the future directions of native thread for Java on windows thread, Pthread, Intel TBB through JNI beneath windows 64-bit platforms and other platform besides. Furthermore, it articulates additional opening to pursue approaching developments on parallel programming models through Java

1997

Description/Abstract We outline an extension of Java for programming with distributed arrays. The basic programming style is Single Program Multiple Data (SPMD), but parallel arrays are provided as new language primitives. Further extensions include three distributed control constructs, the most important being a data-parallel loop construct. Communications involving distributed arrays are handled through a standard library of collective operations.

1996

Parallel processing has emerged as a key enabling technology in modern computers, driven by the ever-increasing demand for higher performance, lower costs and sustained productivity in real-life applications. At the same time, the Internet, whose exponential growth in the last 4 years can be greatly attributed to the ever-increasing popularity of the World-Wide Web, has become a virtual in nite source of information and processing resources. More recently, the Java programming language has been ...

2008

SCOOP is a minimal extension to the sequential object-oriented programming model for concurrency. The extension consists of one keyword (separate) that avoids explicit thread declarations, synchronized blocks, explicit waits, and eliminates data races and atomicity violations by construction through a set of compiler rules. It attempts to guarantee fairness via use of a global scheduler. We present a new implementation of SCOOP for Java, called JSCOOP. JSCOOP introduces a new set of annotations modeled after SCOOP keywords, as well as several core library classes which provide the support necessary to implement the SCOOP semantics. A prototype Eclipse plug-in allows for the creation of JSCOOP projects. The plug-in does syntax checking and detects consistency problems at compile time. The use of JSCOOP is demonstrated by an example.

Science of Computer Programming, 2005

Most synchronizers (locks, barriers, etc.) in the J2SE1.5 java.util.concurrent package are constructed using a small framework based on class AbstractQueuedSynchronizer. This framework provides common mechanics for atomically managing synchronization state, blocking and unblocking threads, and queuing. The paper describes the rationale, design, implementation, usage, and performance of this framework.