The term inheritance anomaly was coined in 1993 by Matsuoka and Yonezawa [15] to refer to the problems arising by the coexistence of inheritance and concurrency in concurrent object oriented languages (COOLs). The quirks arising by such combination have been observed since the early eighties, when the first experimental COOLs were designed [3]. In the nineties COOLs turned from research topic to widely used tools in the everyday programming practice, see e.g. the Java [9] experience. This expository paper extends the survey presented in [15] to account for new and widely used COOLs, most notably Java and 

Milicia, G.

Sassone, V.

English

Southampton (e-Prints Soton)

public class Buffer {protected Object[] buf;protected int max;protected int current = 0;public Buffer(int max) {this.max = max;buf = new Object[max];}public virtual void put(Object v) {Monitor.Enter(this);while (current>=max) { Monitor.Wait(this); }buf[current] = v;current++;Monitor.PulseAll(this);Monitor.Exit(this);}[MethodImpl(MethodImplOptions.Synchronized)]public virtual Object get() {while (current<0) { Monitor.Wait(this); }current--;Object ret = buf[current];Monitor.PulseAll(this);return ret;}}Figure 3: Buﬀer in C]SCOOP is currently available only through a proof-of-concept im-plementation [7], yet it is likely to be the future of concurrency inEiﬀel.Syntactically SCOOP’s impact is minimal, only one keywordneeds to be introduced: separate. Semantically the changes aremore profound and interesting. The separate keyword can beapplied to classes, e.g. separate class NAME, and to object in-stances, e.g. o:separate TYPE. Intuitively the keyword means thatoperations on the entity it refers to might be executed concurrentlyin their own process. A method call is said to be separate if itrefers to a separate object. For instance, the call x.f() is sepa-rate if x is a separate object. In contrast with Java and C], separatecalls in SCOOP can be either asynchronous or synchronous. In theﬁrst case the syntax is simply x.f(), in the second case we writey:=x.f(), called ‘wait by necessity’ in SCOOP terminology. Ev-ery method of a separate object is executed in mutual exclusion, toavoid the diﬃculties arising from race conditions.Eiﬀel is based on the design by contract paradigm. Methods areusually associated with a precondition, introduced by the keywordrequire, and a post-condition, denoted by ensure. Additionally,classescanbeassociatedwithaninvariant, whichtheymustrespectat any time. Consider the Eiﬀel class implementing a (sequential)bounded buﬀer in Figure 5. The method get has a preconditionensuring a non-empty buﬀer. Similarly its post-condition guaran-tees that after its execution the buﬀer will not be full. Althoughdeceivingly similar to method guards, assertions have a diﬀerentsemantics. Recall that we are still in a sequential world. Asser-tion violation does not result in a client waiting for the assertion tobecome true; rather, a run-time exception is thrown.The assertion mechanism breaks down in a concurrent setting, aswell known both in practical and theoretical communities. Meyercalls the resulting situation the concurrent precondition paradox.Indeed, the design-by-contract methodology is based on the no-tion that if a precondition is satisﬁed, the client calling a routine isguaranteed a result in line with the routine’s post-condition. If wepublic class HistoryBuffer : Buffer {bool afterGet = false;public HistoryBuffer(int max) : base(max) {}[MethodImpl(MethodImplOptions.Synchronized)]public Object gget() {while ((current<=0)||(afterGet)) {Monitor.Wait(this);}afterGet = false;return base.get();}[MethodImpl(MethodImplOptions.Synchronized)]public override Object get() {Object o = base.get();afterGet = true;return o;}[MethodImpl(MethodImplOptions.Synchronized)]public override void put(Object v) {base.put(v);afterGet = false;}}Figure 4: HistoryBuﬀer in C]class BBUF[G] creation makefeature ...put(x : G) isrequire not fulldo ... ensure not empty endget : G isrequire not emptydo ... ensure not full endendFigure 5: (Sequential) Bbuf in Eiﬀelconsider a concurrent execution of the bounded buﬀer above (addthe separate keyword to the class deﬁnition), we see that this isclearly not the case. No matter how hard a client tries to satisfythe method’s preconditions, another client can modify them con-currently. This problem leads to modiﬁed the precondition seman-tics for separate objects. Preconditions for separate objects, calledwait conditions, are essentially equivalent to method guards. Thesemantic of a wait condition is:‘Before being executed a separate call must wait tillit gains exclusive ownership of the separate object itrefers to and till its wait-conditions are all satisﬁed.’Wait-conditions are prey to the history-dependent variety of theanomaly. Let us note that the bounded buﬀer in Figure 5 can bemade concurrent simply by changing the ﬁrst line of the class deﬁ-nition from: class BBUF[G] to: separate class BBUF[G]From this modiﬁed deﬁnition we can derive a class implementingan HistoryBuffer as shown in Figure 6. Again, we are forced toadd a boolean ﬂag, after_get, to check whether the last methodto be executed was a get or not. This brings forth the need to re-deﬁne the inherited methods get and put. Despite a signiﬁcantlydiﬀerent concurrency model, we face the same scenario seen forboth Java and C]. The core of the matter is that the inheritance ano-maly depends only on the language’s synchronization mechanisms,and wait conditions are intimately related to method guards.

A run-time system for SCOOP.

Abstracting Object Interactions Using Composition Filters.

Abstracting process-to-function relations in concurrent object-oriented applications.

Analysis of inheritance anomaly in object-oriented concurrent programming language.

Applying formal methods to programming language design and implementation.

Aspect-oriented programming.

Composing Concurrent Objects.

Design and experience.

Eiﬀel: The Language.

Inheritance and synchronization in concurrent OOP.

Inheritance in actor-based concurrent object-oriented languages.

Jeeg: A programming language for concurrent objects synchronization.

Jeeg: Temporal constraints for the synchronization of concurrent objects.

Modern concurrency abstractions for C].

Monitors: an operating system structuring concept.

Object-Oriented Software Construction.

On the Design of the Object-Oriented Language Sina.

Synchronization Rings – Composable Synchronization for Object-Oriented Systems.

The C++ Programming Language 2nd edition.

The Java Language Speciﬁcation Second Edition. Sun Microsystems,

The reﬂexive chemical abstract machine and the join-calculus.

The temporal logic of programs.

The Inheritance Anomaly: Ten years after

http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.11.130

The Inheritance Anomaly: Ten years after

Abstract

Similar works

Full text

Available Versions

Southampton (e-Prints Soton)