Exclusion requirements and potential concurrency for composite objects

Concurrent object-oriented systems must prevent the interference that may arise when multiple threads simultaneously access shared components. We present a simple approach for implementing flexible locking strategies in an object-oriented system, in which the components themselves may be composite objects. We express exclusion requirements as sets of conflict pairs on component interfaces. Given knowledge of the dependency between the interface of a composite object and its internal components, we show how external exclusion requirements can be calculated from internal requirements, and further, how any potential concurrent activity outside an object can be projected into potential concurrency for the internal components.With our approach we can defer the distribution of locks in the system until deployment: the placement of locks and choice of lock type for a component can depend on its operating environment. A Galois connection between the outward mapping of exclusion requirements, and the inward mapping of potential concurrency, limits how many locks are worth considering. In this paper we only deal with exclusion control, including mutexes, read-write locks and read-write sets, and do not cover state-dependent locking or transaction-based approaches.

[1]  James Noble,et al.  Aspects of Synchronization , 1997 .

[2]  G. G. Stokes "J." , 1890, The New Yale Book of Quotations.

[3]  Suh-Yin Lee,et al.  A Multi-Granularity Locking Model for Concurrency Control in Object-Oriented Database Systems. , 1992 .

[4]  O. J. Dahl,et al.  Simula Begin , 1979 .

[5]  Doug Lea,et al.  Concurrent Programming In Java , 1996 .

[6]  Feipei Lai,et al.  7th Asia-Pacific Computer Systems Architecture Conference , 2002 .

[7]  Martin C. Rinard,et al.  A parameterized type system for race-free Java programs , 2001, OOPSLA '01.

[8]  C. A. R. Hoare,et al.  Monitors: an operating system structuring concept , 1974, CACM.

[9]  Gregor Kiczales,et al.  D: A Language Framework for Distributed Programming , 1997 .

[10]  Gul Agha,et al.  Research directions in concurrent object-oriented programming , 1993 .

[11]  Gregor Kiczales,et al.  Aspect-oriented programming , 2001, ESEC/FSE-9.

[12]  Per Brinch Hansen,et al.  Operating System Principles , 1973 .

[13]  Cédric Fournet,et al.  The Join Calculus: A Language for Distributed Mobile Programming , 2000, APPSEM.

[14]  Theo Härder,et al.  Concurrency Control in Nested Transactions with Enhanced Lock Models for KBMSs , 1995, DEXA.

[15]  Wolfram Schulte,et al.  Verification of Multithreaded Object-Oriented Programs with Invariants , 2004 .

[16]  David Holmes,et al.  Exclusion for composite objects , 2000, OOPSLA '00.

[17]  Christopher G. Lasater,et al.  Design Patterns , 2008, Wiley Encyclopedia of Computer Science and Engineering.

[18]  Rachid Guerraoui,et al.  Concurrency and distribution in object-oriented programming , 1998, CSUR.

[19]  Aaron Greenhouse,et al.  Assuring and evolving concurrent programs: annotations and policy , 2002, Proceedings of the 24th International Conference on Software Engineering. ICSE 2002.

[20]  Brian A. Davey,et al.  An Introduction to Lattices and Order , 1989 .

[21]  Michael Philippsen,et al.  A survey of concurrent object-oriented languages , 2000, Concurr. Pract. Exp..

[22]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[23]  Lodewijk Bergmans,et al.  Composing Synchronization and Real-Time Constraints , 1995, J. Parallel Distributed Comput..

[24]  Doug Lea Concurrent Programming in Java. Second Edition: Design Principles and Patterns , 1999 .

[25]  David Holmes,et al.  Aspects of synchronisation , 1997, Proceedings. Technology of Object-Oriented Languages and Systems, TOOLS 25 (Cat. No.97TB100239).

[26]  James Noble,et al.  Ownership types for flexible alias protection , 1998, OOPSLA '98.

[27]  Satoshi Matsuoka,et al.  Analysis of inheritance anomaly in object-oriented concurrent programming languages , 1993 .

[28]  Doug Lea,et al.  Concurrent programming in Java - design principles and patterns , 1996, Java series.

[29]  G. Stewart Von Itzstein,et al.  Applications of Join Java , 2002 .

[30]  HärderTheo,et al.  Concurrency control issues in nested transactions , 1993, VLDB 1993.

[31]  Michael Philippsen A survey of concurrent object-oriented languages , 2000 .

[32]  Luca Cardelli,et al.  Modern concurrency abstractions for C# , 2002, TOPL.

[33]  Denis Caromel,et al.  Sequential Object Monitors , 2004, ECOOP.

[34]  Grady Booch,et al.  Software Component with ADA , 1987 .

[35]  Sophia Drossopoulou,et al.  Ownership, encapsulation and the disjointness of type and effect , 2002, OOPSLA '02.

[36]  James Noble,et al.  Simple Ownership Types for Object Containment , 2001, ECOOP.

[37]  Suh-Yin Lee,et al.  A Multi-Granularity Locking Model for Concurrency Control in Object-Oriented Database Systems , 1996, IEEE Trans. Knowl. Data Eng..