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.