Concurrency abstractions for programming languages using optimistic protocols

Concurrency control in modern programming languages is typically managed using mechanisms based on mutual exclusion, such as mutexes or monitors. All such mechanisms share similar properties that make construction of scalable and robust applications a non-trivial task. Implementation of user-defined protocols synchronizing concurrent shared data accesses requires programmers to make careful use of mutual-exclusion locks in order to avoid safety-related problems, such as deadlock or priority inversion. On the other hand, providing a required level of safety may lead to oversynchronization and, as a result, negatively affect the level of achievable concurrency. Transactions are a concurrency control mechanism developed in the context of database systems. Transactions offer a higher level of abstraction than mutual exclusion which simplifies implementation of synchronization protocols. Additionally, in order to increase concurrency, transactions relax restrictions on the interleavings allowed between concurrent data access operations, without compromising safety. This dissertation presents a new approach to managing concurrency in programming languages, drawing its inspiration from optimistic transactions. This alternative way of looking at concurrency management issues is an attempt to improve the current state-of-the-art both in terms of performance and with respect to software engineering benefits. Three different approaches are presented here: revocable monitors are an attempt to improve traditional mutual exclusion, safe futures propose a new way of thinking about concurrency in a context of imperative programming languages and, finally, transactional monitors try to reconcile transactions and mutual exclusion within a single concurrency abstraction