ACM Computing Surveys (CSUR)
Programming with POSIX threads
Programming with POSIX threads
Asynchronous group mutual exclusion (extended abstract)
PODC '98 Proceedings of the seventeenth annual ACM symposium on Principles of distributed computing
An alternative to event queues for synchronization in monitors
Communications of the ACM
Monitors: an operating system structuring concept
Communications of the ACM
Communications of the ACM
Concurrent control with “readers” and “writers”
Communications of the ACM
The structure of the “THE”-multiprogramming system
Communications of the ACM
The C++ Programming Language, Third Edition
The C++ Programming Language, Third Edition
Java Language Specification, Second Edition: The Java Series
Java Language Specification, Second Edition: The Java Series
C# Language Specification
A Critique of Java for Concurrent Programming
IEEE Distributed Systems Online
Cooperating Sequential Processes, Technical Report EWD-123
Cooperating Sequential Processes, Technical Report EWD-123
ACM Transactions on Programming Languages and Systems (TOPLAS)
The java.util.concurrent synchronizer framework
Science of Computer Programming - Special issue: Concurrency and synchronization in Java programs
The programming language Concurrent Pascal
IEEE Transactions on Software Engineering
Hi-index | 0.00 |
Most programming languages use monitors with explicit signals for synchronization in shared-memory programs. Requiring programmers to signal threads explicitly results in many concurrency bugs due to missed notifications, or notifications on wrong condition variables. In this paper, we describe an implementation of an automatic signaling monitor in Java called AutoSynch that eliminates such concurrency bugs by removing the burden of signaling from the programmer. We show that the belief that automatic signaling monitors are prohibitively expensive is wrong. For most problems, programs based on AutoSynch are almost as fast as those based on explicit signaling. For some, AutoSynch is even faster than explicit signaling because it never uses signalAll, whereas the programmers end up using signalAll with the explicit signal mechanism. AutoSynch} achieves efficiency in synchronization based on three novel ideas. We introduce an operation called closure that enables the predicate evaluation in every thread, thereby reducing context switches during the execution of the program. Secondly, AutoSynch avoids signalAll by using a property called relay invariance that guarantees that whenever possible there is always at least one thread whose condition is true which has been signaled. Finally, AutoSynch uses a technique called predicate tagging to efficiently determine a thread that should be signaled. To evaluate the efficiency of AutoSynch, we have implemented many different well-known synchronization problems such as the producers/consumers problem, the readers/writers problems, and the dining philosophers problem. The results show that AutoSynch is almost as efficient as the explicit-signal monitor and even more efficient for some cases.