90 ;;Quote: use threads for ten processors, slow devices, user-invoked actions, client requests to a server, deferred work

92 ;;Quote: a mutex or critical section is the simplest primitive for accessing shared variables; lock a mutex, use shared variables, unlock the mutex and release a blocked thread

93 ;;Quote: a monitor consists of shared data, a mutex, and zero or more condition variables

93+;;Quote: the Wait operation unlocks a mutex and blocks on a condition variable; use Signal and Broadcast to unblock

93+;;Quote: use condition variables when one-at-a-time mutual exclusion (i.e., mutex) is not sufficient

94 ;;Quote: AlertWait waits on a mutex and condition variable until a signal or explicit alert; an alert raises an exception

94+;;Quote: use TestAlert during long-running computations to allow thread interruption

97 ;;Quote: a mutex protects the invariant of the associated data; restore the invariant before calling Wait or Signal

98 ;;Quote: avoid deadlocks by applying a partial order to the acquisition of mutexes; condition variables may still cause deadlocks

101 ;;Quote: protect all condition variables with a boolean expression; guarantees that the expression is true despite an inconsistent Signal or Broadcast

101+;;Quote: Modula-3's condition variables are simpler than Hoare's original design for monitors

109 ;;Quote: use multiple threads in place of asynchronous operations with interrupts or Unix signals

111 ;;Quote: a pipeline is a chain of producer-consumer threads; if evenly balanced, it makes effective use of multiple processors

113 ;;Quote: avoid having many more runnable threads than processors unless the threads are blocked on condition variables

115 ;;Quote: use up-calls to transfer incoming network data, user input, or status changes to higher level processes; avoids context switches; used for high-performance networks

116 ;;Quote: use version stamps for cached data shared by multiple threads; raise an exception if the version stamp does not match

117 ;;Quote: use a work crew, i.e., a fixed pool of threads, to efficiently process many queued requests

117 ;;Quote: always design a library interface for multiple threads; re-entrant (perhaps by mutex), no results in shared global variables, no asynchronous returns

118 ;;Quote: always protect shared data with a mutex and boolean wait expressions

118 ;;Quote: deadlocks are easy to detect; use a debugger to look at relevant threads, especially those tied to a mutex or condition variable