Concurrency - state models and Java programs

2006

A sequential program has a single thread of control. A concurrent program has multiple threads of control allowing it perform multiple computations in parallel and to control multiple external activities which occur at the same time. Concurrency: introduction 3 ©Magee/Kramer Why Concurrent Programming? Performance gain from multiprocessing hardware parallelism. Increased application throughput an I/O call need only block one thread. Increased application responsiveness high priority thread for user requests. More appropriate structure for programs which interact with the environment, control multiple activities and handle multiple events. Concurrency: introduction 4 ©Magee/Kramer Do I need to know about concurrent programming? ♦ Therac-25 computerised radiation therapy machine Concurrent programming errors contributed to accidents causing deaths and serious injuries. ♦ Mars Rover Problems with interaction between concurrent tasks caused periodic software resets reducing availability for exploration. Concurrency is widespread but error prone. Concurrency: introduction 5 ©Magee/Kramer a Cruise Control System ♦ Is the system safe? ♦ Would testing be sufficient to discover all errors? When the car ignition is switched on and the on button is pressed, the current speed is recorded and the system is enabled: it maintains the speed of the car at the recorded setting. Pressing the brake, accelerator or off button disables the system. Pressing resume re-enables the system. buttons Concurrency: introduction 6 ©Magee/Kramer models A model is a simplified representation of the real world. Engineers use models to gain confidence in the adequacy and validity of a proposed design. ♦ focus on an aspect of interest-concurrency ♦ model animation to visualise a behaviour ♦ mechanical verification of properties (safety & progress) Models are described using state machines, known as Labelled Transition Systems LTS. These are described textually as finite state processes (FSP) and displayed and analysed by the LTSA analysis tool.

In Concurrent Programming in Java, Second Edition, you will find thoroughly updated coverage of the Java 2 platform and new or expanded coverage of:

Information Processing Letters, 1999

First Latin American Conference on Pattern …, 2001

2008 13th Asia-Pacific Computer Systems Architecture Conference, 2008

This is a discussion paper on a very important topic that is about to become mainstream. It deals with the issues of software engineering in concurrent systems. It introduces this topic and illustrates the arguments for a change of perspective. It underlines these arguments with two examples, an asynchronous stream-based programming model and an asynchronous thread-based virtual machine model. Both support concurrency on very different abstractions but both capture similar support for concurrency engineering.

2013 13th International Conference on Application of Concurrency to System Design, 2013

Many novel programming models for concurrency have been proposed in the wake of the multicore computing paradigm shift. These models aim to raise the level of abstraction for expressing concurrency and synchronization in a program, thereby helping programmers avoid programming errors. This goal, however, causes the semantics of the models to become ever more complex and increases the risk of design flaws. Such flaws can have costly consequences if they are discovered after compiler and runtime support has been developed. It is therefore beneficial to verify the models beforehand. This thesis proposes to prototype concurrency models using executable formal specifications. The prototype is useful from the beginning to the end of a model development. Initially, developers can use the prototype to test and correct the core of the model. As the development continues, developers can expand the prototype iteratively. For each extension, they enhance the specification, test the extension against the rest of the model, and apply corrections where necessary. Once the development is completed, the prototype serves as a reference. This thesis applies the prototyping method to SCOOP, an object-oriented concurrency model. It demonstrates how the method facilitates the process of finding and resolving flaws in SCOOP and two extensions. In particular, it applies the method to extend SCOOP with (1) an exception mechanism to handle exceptions resulting from asynchronous calls and (2) a mechanism for fast and safe data sharing, reducing execution time by several orders of magnitude on data-intensive parallel programs. This effort results in 16 clarifications across various aspects, all included in a comprehensive executable formal specification in Maude. This thesis also presents new SCOOP-specific performance metrics and a technique to compute them from event traces. Having a verified concurrency model does not guarantee that programmers write efficient concurrent programs. It is hence necessary to provide performance analysis tools that assist programmers in their task. Since SCOOP differs considerably from established models, reusing existing performance metrics is not an option. Instead, the new metrics are specifically designed for SCOOP. A case study on optimizing a robot control software iii iv Abstract demonstrates the usefulness of these metrics. As a result of this thesis, SCOOP has an executable formal specification for future SCOOP developers, new mechanisms for exception handling and data sharing, as well as SCOOP-specific performance metrics. Having demonstrated the benefits of the method on an extensive concurrency model, we believe that the method can also benefit other models-new or mature.

2005

1MPI Software Technology, Inc., 101 S. Lafayette St., Suite 33, Starkville, MS 39759, U.S.A. 2Department of Electrical and Computer Engineering, Mississippi State University, P.O. Box 9571, Mississippi State, MS 39762, U.S.A. 3Department of Computer Information Sciences, University of Alabama at Birmingham, 1300 University Boulevard, Birmingham, AL 35294-1170, U.S.A. 4Private Consultant, Starkville, MS 39759, U.S.A.

2000

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.

Proceedings Sixth IEEE International Conference on Engineering of Complex Computer Systems. ICECCS 2000, 2000

The task of programming concurrent systems is substantially more dificult than the task of programming sequential systems with respect to both correctness and eflciency. In this paper we describe a constraint-based methodology for writing concurrent applications. A system is modeled as: (a) a set of processes containing a sequence of "markers" denoting the processes points of interest; and (b) a constraint store. Process synchronization is specijied by incrementally adding constraints on the markers' execution order into the constraint store. The constraint store contains a declarative specijication based on a temporal constraint logic program. The store, thus, acts as a coordination entity which on the one hand encapsulates the system synchronization requirements, and on the other hand, provides a declarative specijication of the system concurrency issues, This provide great advantages in writing concurrent programs and manipulating them while preserving correctness.