anchor.diff:    `(mt:with-mutex-lock (,place) ,@body))
   
   (defun make-recursive-lock (&optional name)
  -  (mt:make-mutex :name name :recursive-p t))
  -
  -;;; XXX acquire-recursive-lock and release-recursive-lock are actually
  -;;; complicated because we can't use control stack tricks.  We need to
  -;;; actually count something to check that the acquire/releases are
  -;;; balanced
  +  (mt:make-mutex :name (or name "Anonymous recursive lock")
  +                 :recursive-p t))
   
   (defmacro with-recursive-lock-held ((place) &body body)
     `(mt:with-mutex-lock (,place) ,@body))
  
positive.code: ;;; Resource contention: condition variables
  
  (defun make-condition-variable ()
    (mt::make-exemption))
  
  (defun condition-wait (condition-variable lock)
    (mt:exemption-wait condition-variable lock))
  
negative.code: 
  (in-package #:bordeaux-threads)
  
  (defvar *thread-join-mutex* nil)
  
  ;;; initialize *thread-join-mutex* for loading thread
  ;;; NB: all existing threads at time of loading(even those not created by B-T)
  ;;;     will become "joinable".
  (eval-when (:load-toplevel)
    (mapcar
     (lambda (thr)
       (unless (mt:symbol-value-thread '*thread-join-mutex* thr)
         (mt:thread-interrupt
          thr
          :function #'mt:mutex-lock
          :arguments (list (setf (mt:symbol-value-thread '*thread-join-mutex* T)
                                 (mt:make-mutex))))))
     (mt:list-threads)))
  
  ;;; Thread Creation
  (defun %make-thread (function name)
    (mt:make-thread
     (lambda ()
       (let ((*thread-join-mutex* (mt:make-mutex)))
         (mt:with-mutex-lock (*thread-join-mutex*)
           (funcall function))))
     :name name
     :initial-bindings mt:*default-special-bindings*))
  
  (defun current-thread ()
    (mt:current-thread))
  