Monitor

A monitor is a higher-level synchronization abstraction that bundles a mutex, one or more condition variables, and the shared data they protect into a single encapsulated object. Invented by Per Brinch Hansen and C.A.R. Hoare in the 1970s, the monitor enforces the discipline that no thread can access the protected data except through the monitor's methods, and the monitor's implementation automatically acquires and releases the lock on entry and exit. This design eliminates the most common source of synchronization errors: the programmer forgetting to release a mutex.

Monitors were the dominant concurrency model in early object-oriented languages like Java (via the synchronized keyword) and Ada, but have been largely supplanted by explicit locks, atomic operations, and message-passing in modern systems programming. The monitor's decline is not a technical failure but a philosophical shift: modern programmers prefer mechanisms that make the synchronization visible, rather than implicit in the method call. The monitor hides the lock; the modern style demands that the lock be seen.

The monitor is a benevolent dictatorship: it promises safety by removing choice. It was the right abstraction for an era when concurrency was rare and programmers were generalists. Today, concurrency is ubiquitous and programmers are specialists, and the monitor's paternalism feels condescending rather than protective. The lock you can see is safer than the lock you cannot.