diff --git a/quicklisp/dists/quicklisp/software/bordeaux-threads-0.8.0/bordeaux-threads.asd b/quicklisp/dists/quicklisp/software/bordeaux-threads-0.8.0/bordeaux-threads.asd
--- a/quicklisp/dists/quicklisp/software/bordeaux-threads-0.8.0/bordeaux-threads.asd
+++ b/quicklisp/dists/quicklisp/software/bordeaux-threads-0.8.0/bordeaux-threads.asd
@@ -11,17 +11,17 @@
   #+corman  (require :threads))
 
 (eval-when (:compile-toplevel :load-toplevel :execute)
-  #+(or (and allegro multiprocessing)
-        armedbear
+  #+(or armedbear
+        (and allegro multiprocessing)
+        (and clisp mt)
+        (and openmcl openmcl-native-threads)
         (and cmu mp)
-        scl
         corman
-        (and digitool ccl-5.1)
         (and ecl threads)
         lispworks
-        (and openmcl openmcl-native-threads)
+        (and digitool ccl-5.1)
         (and sbcl sb-thread)
-        (and clisp mt))
+        scl)
   (pushnew :thread-support *features*))
 
 (asdf:defsystem :bordeaux-threads
@@ -47,10 +47,10 @@
                         #+(and thread-support digitool)  "impl-mcl"
                         #+(and thread-support sbcl)      "impl-sbcl"
                         #+(and thread-support scl)       "impl-scl"
-                        #-thread-support                 "unsupported")
+                        #-thread-support                 "impl-null")
                  #+(and thread-support lispworks (not lispworks6))
                  (:file "impl-lispworks-condition-variables")
-                 #+(and thread-support (or armedbear digitool))
+                 #+(and thread-support digitool)
                  (:file "condition-variables")
                  (:file "default-implementations"))))
   :in-order-to ((asdf:test-op (asdf:load-op bordeaux-threads-test)))
diff --git a/quicklisp/dists/quicklisp/software/bordeaux-threads-0.8.0/src/impl-abcl.lisp b/quicklisp/dists/quicklisp/software/bordeaux-threads-0.8.0/src/impl-abcl.lisp
--- a/quicklisp/dists/quicklisp/software/bordeaux-threads-0.8.0/src/impl-abcl.lisp
+++ b/quicklisp/dists/quicklisp/software/bordeaux-threads-0.8.0/src/impl-abcl.lisp
@@ -3,6 +3,8 @@
 #|
 Copyright 2006, 2007 Greg Pfeil
 
+Reimplemented with java.util.concurrent.locks.ReentrantLock by Mark Evenson 2011.
+
 Distributed under the MIT license (see LICENSE file)
 |#
 
@@ -12,7 +14,7 @@
 ;;; src/org/armedbear/lisp/LispThread.java
 
 (deftype thread ()
-  'ext:thread)
+  'threads:thread)
 
 ;;; Thread Creation
 
@@ -30,31 +32,88 @@
 
 ;;; Resource contention: locks and recursive locks
 
+(defstruct mutex name lock)
+(defstruct (mutex-recursive (:include mutex)))
+
+;; Making methods constants in this manner avoids the runtime expense of
+;; introspection involved in JCALL with string arguments.
+(defconstant +lock+ 
+  (jmethod "java.util.concurrent.locks.ReentrantLock" "lock"))
+(defconstant +try-lock+ 
+  (jmethod "java.util.concurrent.locks.ReentrantLock" "tryLock"))
+(defconstant +is-held-by-current-thread+ 
+  (jmethod "java.util.concurrent.locks.ReentrantLock" "isHeldByCurrentThread"))
+(defconstant +unlock+ 
+  (jmethod "java.util.concurrent.locks.ReentrantLock" "unlock"))
+(defconstant +get-hold-count+ 
+  (jmethod "java.util.concurrent.locks.ReentrantLock" "getHoldCount"))
+
 (defun make-lock (&optional name)
-  (declare (ignore name))
-  (threads:make-thread-lock))
+  (make-mutex 
+   :name (or name "Anonymous lock")
+   :lock (jnew "java.util.concurrent.locks.ReentrantLock")))
 
 (defun acquire-lock (lock &optional (wait-p t))
-  (declare (ignore wait-p))
-  (threads:thread-lock lock))
+  (check-type lock mutex)
+  (when (jcall +is-held-by-current-thread+ (mutex-lock lock))
+    (error "Non-recursive lock being reacquired by owner."))
+  (cond
+    (wait-p
+     (jcall +lock+ (mutex-lock lock))
+     t)
+    (t (jcall +try-lock+ (mutex-lock lock)))))
 
 (defun release-lock (lock)
-  (threads:thread-unlock lock))
+  (check-type lock mutex)
+  (unless (jcall +is-held-by-current-thread+ (mutex-lock lock))
+    (error "Attempt to release lock not held by calling thread."))
+  (jcall +unlock+ (mutex-lock lock))
+  (values))
 
-(defmacro with-lock-held ((place) &body body)
-  `(threads:with-thread-lock (,place) ,@body))
+(defun make-recursive-lock (&optional name)
+  (make-mutex-recursive
+   :name (or name "Anonymous lock")
+   :lock (jnew "java.util.concurrent.locks.ReentrantLock")))
+
+(defun acquire-recursive-lock (lock &optional (wait-p t))
+  (check-type lock mutex-recursive)
+  (cond
+    (wait-p
+     (jcall +lock+ (mutex-recursive-lock lock))
+     t)
+    (t (jcall +try-lock+ (mutex-recursive-lock lock)))))
+
+(defun release-recursive-lock (lock)
+  (check-type lock mutex-recursive)
+  (unless (jcall +is-held-by-current-thread+ (mutex-lock lock))
+    (error "Attempt to release lock not held by calling thread."))
+  (jcall +unlock+ (mutex-lock lock))
+  (values))
 
 ;;; Resource contention: condition variables
 
 (defun thread-yield ()
-  (sleep 0))
+  (sleep 0.01))
+
+(defstruct condition-variable
+  (name "Anonymous condition variable"))
+
+(defun condition-wait (condition lock)
+  (threads:synchronized-on condition
+    (release-lock lock)
+    (threads:object-wait condition))
+  (acquire-lock lock))
+
+(defun condition-notify (condition)
+  (threads:synchronized-on condition
+     (threads:object-notify condition)))
 
 ;;; Introspection/debugging
 
 (defun all-threads ()
   (let ((threads ()))
-    (threads:mapcar-threads (lambda (th)
-			      (push th threads)))
+    (threads:mapcar-threads (lambda (thread)
+			      (push thread threads)))
     (reverse threads)))
 
 (defun interrupt-thread (thread function &rest args)
diff --git a/quicklisp/dists/quicklisp/software/bordeaux-threads-0.8.0/src/pkgdcl.lisp b/quicklisp/dists/quicklisp/software/bordeaux-threads-0.8.0/src/pkgdcl.lisp
--- a/quicklisp/dists/quicklisp/software/bordeaux-threads-0.8.0/src/pkgdcl.lisp
+++ b/quicklisp/dists/quicklisp/software/bordeaux-threads-0.8.0/src/pkgdcl.lisp
@@ -5,6 +5,8 @@
 (defpackage bordeaux-threads
   (:nicknames #:bt)
   (:use #:cl #:alexandria)
+  #+abcl
+  (:import-from :java #:jnew #:jcall #:jmethod)
   (:export #:thread #:make-thread #:current-thread #:threadp #:thread-name
            #:start-multiprocessing
            #:*default-special-bindings* #:*standard-io-bindings*
diff --git a/quicklisp/dists/quicklisp/software/bordeaux-threads-0.8.0/version.lisp-expr b/quicklisp/dists/quicklisp/software/bordeaux-threads-0.8.0/version.lisp-expr
--- a/quicklisp/dists/quicklisp/software/bordeaux-threads-0.8.0/version.lisp-expr
+++ b/quicklisp/dists/quicklisp/software/bordeaux-threads-0.8.0/version.lisp-expr
@@ -1,1 +1,2 @@
-"0.8.0"
+;; -*- lisp -*-
+"0.8.0.99"
