• Corpus ID: 3792728

Java Concurrency in Practice

  title={Java Concurrency in Practice},
  author={Brian Goetz and Timothy Peierls and Joshua J. Bloch and Joseph Bowbeer and David Holmes and Doug Lea},
"I was fortunate indeed to have worked with a fantastic team on the design and implementation of the concurrency features added to the Java platform in Java 5.0 and Java 6. Now this same team provides the best explanation yet of these new features, and of concurrency in general. Concurrency is no longer a subject for advanced users only. Every Java developer should read this book." --Martin Buchholz JDK Concurrency Czar, Sun Microsystems"For the past 30 years, computer performance has been… 

Actors in Scala

This book enables you to leverage the full power of today's and tomorrow's multi-core processors by describing both basic and advanced features of Scala's actor framework in-depth.

Refactoring Java programs using concurrent libraries

Refactoring algorithms are described that address three problems as they rewrite Java code for scalable performance - transformations that may change the behavior of a program, inter-procedural pointer analysis and consistency tests among the candidate code fragments.

An Aspect-based Approach for Concurrent Programming using CSP Features

This paper proposes separating concurrent concerns (CSP code) from the development of sequential Java processes using aspect-oriented programming to implement this separation of concerns and conducts an experiment to evaluate the benefits of the proposed framework.

A Parallelisation Tale of Two Languages

A set of measurements are carried out to compare the execution time and performance of parallel versions of Belousov-Zhabotinsky chemical reaction simulation with cellular automata and Discrete 2D-Convolution.

Concurrency and Parallel Methods for multi-core Platforms

The research of the thesis addresses issues with concurrent programming in Java, available frameworks and methods and how they can be implemented for different kinds of applications, including good scalability, 15 times performance increase compared to the sequential version and improved deterministic behavior.

Refactoring sequential Java code for concurrency via concurrent libraries

This paper presents the tool, Concurrencer, that enables programmers to refactor sequential code into parallel code that uses three j.u.c.concurrent (j.util.c.) concurrent utilities, and shows that ConcurRencer refactors code effectively.

Effective Static Analysis to Find Concurrency Bugs in Java

This paper presents a precise and efficient static concurrency bugs detector building upon the Eclipse JDT and the open source WALA toolkit (which provides advanced static analysis capabilities) and describes a variety of novel heuristics and enhancements to existing analysis techniques which make this detector more practical, in terms of accuracy and performance.

Functional approaches to teaching concurrency

  • M. Lutz
  • Computer Science
    2013 IEEE Frontiers in Education Conference (FIE)
  • 2013
An experiment to include Erlang as part of an existing course on concurrent systems design is reported on, and results will serve as an inspiration (or warning) to others considering such a change.

A study on the most popular questions about concurrent programming

An empirical investigation of the top-250 most popular questions about concurrent programming on StackOverflow found that even though some questions are related to practical problems, most of them arerelated to basic concepts, which were created by well- experienced Stack overflow users.



Concurrent and real-time programming in Java

This book gives a thorough, self-contained account of how the Ada tasking model can be used to construct a wide range of concurrent and real-time systems.

The Java memory model

The new Java model provides a simple interface for correctly synchronized programs -- it guarantees sequential consistency to data-race-free programs and could prove to be a useful basis for other programming languages that currently lack well-defined models, such as C++ and C#.

Thin locks: featherweight synchronization for Java

A new algorithm is proposed that allows lock and unlock operations to be performed with only a few machine instructions in the most common cases, and only require a partial word per object, and was implemented without increasing object size.

Wait-free synchronization

A hierarchy of objects is derived such that no object at one level has a wait-free implementation in terms of objects at lower levels, and it is shown that atomic read/write registers, which have been the focus of much recent attention, are at the bottom of the hierarchy.

Algorithms for mutual exclusion

All of the algorithms in this book have been rewritten in a single language and restructured so that they are easy to understand and compare, and the principles guiding their design are stressed.

Composable memory transactions

This paper presents a new concurrency model, based on transactional memory, that offers far richer composition, and describes new modular forms of blocking and choice that have been inaccessible in earlier work.

Destructors, finalizers, and synchronization

We compare two different facilities for running cleanup actions for objects that are about to reach the end of their life.Destructors, such as we find in C++, are invoked synchronously when an object

Simple, fast, and practical non-blocking and blocking concurrent queue algorithms

Experiments on a 12-node SGI Challenge multiprocessor indicate that the new non-blocking queue consistently outperforms the best known alternatives; it is the clear algorithm of choice for machines that provide a universal atomic primitive (e.g., compare_and_swap or load_linked/store_conditional).

Monitors: an operating system structuring concept

This paper develops Brinch-Hansen's concept of a monitor as a method of structuring an operating system. It introduces a form of synchronization, describes a possible method of implementation in

Design Patterns

This book offers an easy-to-reference library of design patterns as well as some principles of object-oriented programming to help readers become better designers.