Featherweight Monitors with Bacon Bits

Abstract Language-supported synchronization is a source of serious performance problems in Java programs. Even for single threaded programs the overhead of synchronization in compiled Java can be as high as 45%. I address this problem with a new language-level locking algorithm suitable for both uniprocessor and multiprocessor environments. On a Pentium uniprocessor, in the most common case the lock-andunlock overhead for a Java synchronized method is a mere 6 machine cycles when a synchronous thread scheduler is used, or 15 machine cycles when an asynchronous thread scheduler is used. 1 Introduction Monitors [6] are a language-level construct for providing mutually exclusive access to shared data structures in a multi-threaded environment. However, the overhead required by the necessary locking has generally restricted their use to relatively "heavy-weight " objects. Recently, their incorporation in Java [4] has led to renewed interest in monitors, because of both their prevalence and their associated performance problems. Java uses monitor semantics derived from Mesa [13]. In Java, the methods of an object may be declared synchronized meaning that the object must be locked for the duration of the method's execution. Ideally, every Java class would be thread-safe, but because of the overhead of locking, methods are only optionally synchronized