Žárský, Jan · Brno University of Technology Digital Library (Brno University of Technology) · 2021
Contracts for concurrency describe required atomicity of method sequences in concurrent programs. This work proposes a dynamic analyzer to verify programs written in Java against contracts for concurrency. The analyzer was designed to detect violations of parametric contracts with spoilers. The proposed analyzer was implemented as an extension to the RoadRunner framework. Support for accessing the method arguments and return values was added to RoadRunner as a part of the solution. The analyzer was fully implemented and verified on a set of testing programs.
Cited by 0
Max Haustein, Klaus‐Peter Löhr · Concurrency and Computation Practice and Experience · 2005
Abstract The Java programming language has a low‐level concurrency model which is hard to use and does not blend well with inheritance. J AC is an extension of Java that introduces a higher level of concurrency, hiding threads and separating thread synchronization from application logic in a declarative fashion. The emphasis is on limiting the differences between sequential and concurrent code, thus furthering code reuse, and on avoiding inheritance anomalies. This is achieved by taking a middle road between concurrent code on the one hand and complete separation of sequential application logic from concurrency mechanisms on the other. An extensive comparison with related approaches is given for motivating our design decisions. Copyright © 2005 John Wiley & Sons, Ltd.
Cited by 23
Yuri Gurevich, Wolfram Schulte, Charles Wallace · 1999
Abstract. We present a mathematically precise, platform-independent model of Java concurrency using the Abstract State Machine method. We cover all aspects of Java threads and synchronization, gradually adding details to the model in a series of steps. We motivate and explain each concurrency feature, and point out subtleties, inconsistencies and ambiguities in the o cial, informal Java speci cation. 1
Cited by 0
Ruixiang Liu, Wei Liu, Hong Zhu · 2009
JAC is an extended Java that introduces a higher level of concurrency, hiding threads and separating thread synchronization from application logic in a declarative fashion. It attracts people's attention as soon as it appears. But its present version could not support the sharing class static attribute of class object. This paper discusses how to extend JAC specification, how to improve JAC compiler, so that JAC can describe the concurrent programming of sharing class static attribute of class object.
Cited by 0
Rafael M. Duarte, Alexandre Mota, Augusto Sampaio · Information Processing Letters · 2010
Cited by 6
Trinh, Anh · San José State University ScholarWorks (San Jose State University) · 2011
To avoid overheating the chip, chip designers have switched to multi-cores. While multicore CPUs reserve instruction-level parallelism features that help existing applications run as if they were running under single core, applications do not reach speeds two or four times faster. Instead of relying on compiler and hardware to figure out parallelism in source code, software developers now must control parallelism explicitly in their programs. Many programming languages and libraries, such as Java, C# .NET, and OpenMP, are trying to help programmers by providing rich concurrency API. X10 is the new experimental language from IBM Research, which has been under development since 2004 targeting multi-core programming ranging from multi-cores single machine to cluster. This project examines the X10 parallel constructs, compares its usability with the Java language, the OpenMP library, and then compares the performance between X10 and Java language.
Cited by 0Open access
Peter Welch · Lecture notes in computer science · 2002
Cited by 31
Read Ebook Java Concurrency in Practice *Full Online · Zenodo (CERN European Organization for Nuclear Research) · 2020
Read Or Download Java Concurrency in Practice Full Books By by {"isAjaxComplete_B001JSCCH6":"0","isAjaxInProgress_B001JSCCH6":"0"} Brian Goetz (Author) › Visit Amazon's Brian Goetz Page Find all the books, read about the author, and more. See search results for this author Are you an author? Learn about Author Central Brian Goetz (Author)\n\n\nRead Online => Read Java Concurrency in Practice\n\n\nDownload Book => Download Java Concurrency in Practice\n\n\nJava Concurrency in Practice pdf download\nJava Concurrency in Practice read online\nJava Concurrency in Practice epub\nJava Concurrency in Practice vk\nJava Concurrency in Practice pdf\nJava Concurrency in Practice amazon\nJava Concurrency in Practice free download pdf\nJava Concurrency in Practice pdf free\nJava Concurrency in Practice pdf\nJava Concurrency in Practice epub download\nJava Concurrency in Practice online\nJava Concurrency in Practice epub download\nJava Concurrency in Practice epub vk\nJava Concurrency in Practice mobi\n\n\n\n#downloadbook #book #readonline #readbookonline #ebookcollection #ebookdownload #pdf #ebook #epub #kindle
Cited by 0Open access
Faraz Torshizi, Jonathan S. Ostroff, Richard F. Paige et al. · IOS Press eBooks · 2009
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. SCOOP was originally described for the Eiffel programming language. This paper makes two contributions. Firstly, it presents a design pattern for SCOOP, which makes it feasible to transfer SCOOP's concepts to different object-oriented programming languages. Secondly, it demonstrates the generality of the SCOOP model by presenting an implementation of the SCOOP design pattern for Java. Additionally, we describe tools that support the SCOOP design pattern, and give a concrete example of its use in Java.
Cited by 15
2008
� To acquaint the students with the principle of multithreading in modern operating systems. � To motivate the student to be able to enumerate the differences between process and thread. � To show the student how the applications ’ performance and the processor utilization increase when multithreaded applications are used. � To teach the student how to synchronize between multiple threads in the same application. � To educate the student to be able to inspect the problems arose as a result of concurrency. EQUIPMENT REQUIRED 1. A PC operated with Windows or Linux.
Cited by 0
Peter Welch, Herman Roebbers, Tobe Announced (eds et al. · 2014
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. SCOOP was originally described for the Eiffel programming language. This paper makes two contributions. Firstly, it presents a design pattern for SCOOP, which makes it feasible to transfer SCOOP’s concepts to different object-oriented programming lan-guages. Secondly, it demonstrates the generality of the SCOOP model by presenting an implementation of the SCOOP design pattern for Java. Additionally, we describe tools that support the SCOOP design pattern, and give a concrete example of its use in Java.
Cited by 0
Fernández González, Javier · CERN Document Server (European Organization for Nuclear Research) · 2016
Cited by 0
Laurent Daynes, Malcolm P. Atkinson, Patrick Valduriez · 1996
We report on the issues raised when designing a customizable locking mechanism for Persistent Java, a type-safe, object-oriented, orthogonally persistent system based on the language Java. Customizable locking mechanisms are supported by locking capabilities. A locking capability is a book-keeper of locks that automatically acquires locks with a customizable conflict detection mechanism. It implements the concepts of delegation of locks and ignorable conflicts, automatically keeps track of the dependencies created because of allowance of conflicts, supports querying of details about these dependencies, and supports the setting of user-defined notifications for conflicts that can't be ignored. Locking capabilities don't change the Java language specification, and allow use of any Java classes without changing a single line of their code to implement the body of transactions. We also present several novel techniques to implement efficiently this customizable locking mechanism in a persis...
Cited by 0
Danny Dig, John Marrero, Michael D. Ernst · DSpace@MIT (Massachusetts Institute of Technology) · 2009
Parallelizing existing sequential programs to run efficiently on multicores is hard. The Java 5 package java.util.concurrent (j.u.c.) supports writing concurrent programs: much of the complexity of writing thread-safe and scalable programs is hidden in the library. To use this package, programmers still need to reengineer existing code. This is tedious because it requires changing many lines of code, is error-prone because programmers can use the wrong APIs, and is omission-prone because programmers can miss opportunities to use the enhanced APIs. This paper presents our tool, Concurrencer, that enables programmers to refactor sequential code into parallel code that uses three j.u.c. concurrent utilities. Concurrencer does not require any program annotations. Its transformations span multiple, non-adjacent, program statements. A find-and-replace tool can not perform such transformations, which require program analysis. Empirical evaluation shows that concurrencer refactors code effectively: concurrencer correctly identifies and applies transformations that some open-source developers overlooked, and the converted code exhibits good speedup.
Cited by 154Open access
Claude Kaiser, Jean‐François Pradat‐Peyre · 2004
Summary form only given. We present a peer-to-peer cooperation paradigm and several implementations. The paradigm is expressed as a game. The implementations are done in three different languages largely available today (Ada, Java and C with the Posix standard). This allows comparing their programming style and their ability to provide secure programs. Java and Ada are high level languages which allow concurrent programming. Both use the concept of monitor, but their implementation choices make them differ greatly. Posix offers low level system API for concurrent programming. First we present the application contexts in which this concurrency paradigm may be useful, and we summarize the concurrent programming structures of Java, Ada and Posix and finally the coloured Petri nets formalism. The possible colour mutation of chameneos are described. Their concurrent behaviour is specified and analyzed. This leads to the three announced implementations. From this case study, we deduce the strong and weak points of each approach and an appraisal of the concurrent parts of the languages. We end with some possible extensions.
Cited by 15
I. Introduction · 2008
This paper presents a peer-to-peer cooperation paradigm and several implementations. The paradigm is expressed as a game. The implementations are done in three different languages largely available to-day (Ada, Java and C with the Posix
Cited by 0
Łukasz Szweda, Daniel Wilusz, Jakub Flotyński · Lecture notes in computer science · 2012
Cited by 4
Yazeed, Al-Dossari, Layla, Al-Fahad · Umsida Repository (Universitas Muhammadiyah Sidoarjo) · 2024
In the evolving landscape of high-performance software development, mastering concurrency is essential for building responsive, scalable, and efficient Java applications. This article demystifies the core pillars of Java concurrency by delving into thread pools, CompletableFuture, and the groundbreaking virtual threads introduced in Project Loom. It begins by elucidating the traditional thread pool model, emphasizing its role in resource optimization and task parallelism. The discussion then transitions to CompletableFuture, highlighting its power in enabling non-blocking, asynchronous programming with elegant composition of dependent tasks. Finally, the article explores virtual threads—lightweight, scalable threads that promise to simplify concurrency design without sacrificing performance. Through practical examples, performance comparisons, and real-world use cases, this article offers developers a clear roadmap to leverage modern Java concurrency constructs effectively. Whether you're optimizing legacy systems or architecting next-generation services, this comprehensive guide equips you with the knowledge to write clean, concurrent Java code that scales with confidence.
Cited by 0Open access
Marko Boger, Frank Wienberg, Winfried Lamersdorf · 1999
In the development of distributed programs two different concepts have to be considered, each being quite complex even on its own: concurrency and distribution. For both similar problems like synchronization and communication need to be addressed, yet are treated with completely dioeerent mechanisms. This paper presents Dejay, a programming language based on Java that unies concurrency and distribution into the single mechanism of virtual processors. This allows a considerable simplication for the development of distributed or concurrent programs and makes the transition from a local to a distributed environment seamless.
Cited by 0
Aart J. C. Bik, Dennis B. Gannon · 1997
In this paper we show how implicit parallelism in Java programs can be made explicit by a restructuring compiler using the multi-threading mechanism of the language. In particular, we focus on automatically exploiting implicit parallelism in loops and multi-way recursive methods. Expressing parallelism in Java itself clearly has the advantage that the transformed program remains portable. After compilation of the transformed Java program into bytecode, speedup can be obtained on any platform on which the implementation of the JVM (Java Virtual Machine) supports the true parallel execution of threads. Moreover, we will see that the transformations presented in this paper only induce a slight overhead on uni-processors. 1
Cited by 0