here - Stefan-Marr.de

3.3. Common Problems for the Implementation of Concurrency Abstractions
1 object semaphore {
2 class SemaphoreActor () extends Actor {
3 // ...
4 def enter () {
5 if ( num < MAX ) {
6 // critical section
7 num = num + 1; } } }
8
9 def main ( args : Array [ String ]) : Unit = {
10 var gate = new SemaphoreActor ()
11 gate . start
12 gate ! enter // executes on gate ’s thread
13 gate . enter // executes on the main thread
14 } }
Listing 3.1: Example of incomplete State Encapsulation: This semaphore has a race
condition since Scala’s actors do not enforce encapsulation and the actor as well
as the main thread have access to the num field. [Karmani et al., 2009, Fig. 2]
semaphore. The SemaphoreActor has a counter num, which indicates the number
of activities that entered the critical section.
However, Scala’s actor implementation does not guarantee encapsulation.
This makes the gate object simultaneously accessible in the main thread and
the thread of gate, i. e., the SemaphoreActor. Both threads can execute enter
at the same time, leading to a race condition on the num variable, undermining
one of the main benefits of the actor model. If encapsulation would be guaranteed,
as it is for instance in Erlang, this example would work as intended,
because only the owning actor could access num and the data race would not
be possible.
While actors require state encapsulation to yield full engineering benefits,
implementing this guarantee comes either at the cost of a high implementation
complexity or a significant performance impact. The main reason is
that VMs such as the JVM do not provide sufficient abstraction for the notion
of ownership and state encapsulation. AmbientTalk [Van Cutsem et al.,
2007], JCoBox [Schäfer and Poetzsch-Heffter, 2010], and NAct 18 enforce the
discussed encapsulation by construction. The compiler ensures that only socalled
far references can be obtained to objects such as the SemaphoreActor.
These far references enforce state encapsulation to guarantee isolation.
Kilim [Srinivasan and Mycroft, 2008] is an example for another approach to
the problem. Kilim employs compile-time checking based on annotations to
18 http://code.google.com/p/n-act/
73