anchor.diff:  
   ;;; Timeouts
   
  +;; VTZ: is there timeout-function (executed on timeout)?
  +;; How to distinguish between NIL returned from body and timeout ?
   (defmacro with-timeout ((timeout) &body body)
  -  `(mt:with-timeout (,timeout)
  +  `(mt:with-timeout (,timeout nil)
        ,@body))
   
   ;;; Introspection/debugging
   
  +;;; VTZ: mt:list-threads returns all threads that are not garbage collected.
   (defun all-threads ()
  -  (mt:list-threads))
  +  (delete-if-not #'mt:thread-active-p (mt:list-threads)))
   
   (defun interrupt-thread (thread function)
     (mt:thread-interrupt thread :function function))
   
  +(defun destroy-thread (thread)
  +  ;;; VTZ: actually we can kill ourselelf.
  +  ;;; suicide is part of our contemporary life :)
  +  (signal-error-if-current-thread thread)
  +  (mt:thread-interrupt thread :function t))
  +
   (defun thread-alive-p (thread)
     (mt:thread-active-p thread))
   
  +;;; VTZ: the current implementation is trivial and may cause contention
  +;;; if the thread is tried to be joined immediately after its creation
  +;;; or if :initial-bindings argument of make-thread cause entering the debugger
  +(defun thread-join (thread)
  +  (loop while (mt:thread-active-p thread) do
  +       (let ((jmx (mt:symbol-value-thread '*thread-join-mutex* thread)))
  +         (when jmx ; mutex may have not been created
  +           (mt:mutex-lock jmx) ; wait
  +           ; give chance other threads to wait/join as well
  +           (mt:mutex-unlock jmx)))))
  +
   (mark-supported)
  
positive.code:   `(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
  
  (defmacro with-recursive-lock-held ((place) &body body)
    `(mt:with-mutex-lock (,place) ,@body))
  
negative.code: ;;; Resource contention: locks and recursive locks
  
  (defun make-lock (&optional name)
    (mt:make-mutex :name (or name "Anonymous lock")))
  
  (defun acquire-lock (lock &optional (wait-p t))
    (mt:mutex-lock lock :timeout (if wait-p nil 0)))
  
  (defun release-lock (lock)
    (mt:mutex-unlock lock))
  