Programs written in concurrent object-oriented languages, especially ones t
hat employ thread-safe reusable class libraries, can execute synchronizatio
n operations (lock, notify, etc.) at an amazing rate. Unless implemented wi
th utmost care, synchronization can become a performance bottleneck. Furthe
rmore, in languages where every object may have its own monitor, per-object
space overhead must be minimized. To address these concerns, we have devel
oped a meta-lock to mediate access to synchronization data. The meta-lock i
s fast (lock + unlock executes in 11 SPARC(TM) architecture instructions),
compact (uses only two bits of space), robust under contention (no busy-wai
ting), and flexible (supports a variety of higher-level synchronization ope
rations). We have validated the meta-lock with an implementation of the syn
chronization operations in a high-performance product-quality Java(TM) virt
ual machine and report performance data for several large programs.