This paper reports on an experimental implementation of action-based concurrent
objects. Concurrency is expressed by allowing objects to have actions with a
guard and a body, in addition to methods and variables. Condition synchronization
is expressed by method guards protecting entry into an object. An action of
an object can execute any time when its guard is true, with the restriction that at
most one action or methods can execute within an object, thus guaranteeing atomicity.
In principle, all objects can execute in parallel. The appeal of this model
is that it is conceptually simple for programmers and comes with a verification
and refinement theory based on atomic actions that is a straightforward extension
of that for sequential programs. The concurrency model is suited for tightly
coupled shared-memory processors. The implementation makes use of a recent
thread library, NPTL, that supports a large number of kernel threads. Each active
object has its own thread that cycles through the actions, evaluates their guards,
and executes an enabled action. Syntactic constraints restrict when guards need
to be re-evaluated. We compare the efficiency of the generated code with that of
C/Pthreads, Ada, and Java using classical concurrency examples.