Fixes #11282 - Deadlocks with DEBUG logging enabled in jetty-server testing.

jetty-core/jetty-io/src/main/java/org/eclipse/jetty/io/ByteArrayEndPoint.java

@@ -492,13 +492,14 @@ public void setGrowOutput(boolean growOutput)
     public String toString()
     {
         int q;
-        ByteBuffer b;
+        Object b;
         String o;
-        try (AutoLock lock = _lock.lock())
+        try (AutoLock lock = _lock.tryLock())
         {
-            q = _inQ.size();
-            b = _inQ.peek();
-            o = BufferUtil.toDetailString(_out);
+            boolean held = lock.isHeldByCurrentThread();
+            q = held ? _inQ.size() : -1;
+            b = held ? _inQ.peek() : "?";
+            o = held ? BufferUtil.toDetailString(_out) : "?";
         }
         return String.format("%s[q=%d,q[0]=%s,o=%s]", super.toString(), q, b, o);
     }

jetty-core/jetty-server/src/main/java/org/eclipse/jetty/server/internal/HttpChannelState.java

@@ -523,16 +523,18 @@ private boolean lockedLastStreamSend()
     @Override
     public String toString()
     {
-        try (AutoLock ignored = _lock.lock())
+        try (AutoLock lock = _lock.tryLock())
         {
-            return String.format("%s@%x{handling=%s, handled=%b, send=%s, completed=%b, request=%s}",
+            boolean held = lock.isHeldByCurrentThread();
+            return String.format("%s@%x{handling=%s, handled=%s, send=%s, completed=%s, request=%s}",
                 this.getClass().getSimpleName(),
                 hashCode(),
-                _handling,
-                _handled,
-                _streamSendState,
-                _callbackCompleted,
-                _request);
+                held ? _handling : "?",
+                held ? _handled : "?",
+                held ? _streamSendState : "?",
+                held ? _callbackCompleted : "?",
+                held ? _request : "?"
+            );
         }
     }
 
@@ -1247,6 +1249,7 @@ public void succeeded()
          * <p>
          * The implementation maintains the {@link #_streamSendState} before taking
          * and serializing the call to the {@link #_writeCallback}, which was set by the call to {@code write}.
+         *
          * @param x The reason for the failure.
          */
         @Override
@@ -1475,6 +1478,7 @@ else if (LOG.isDebugEnabled())
 
         /**
          * Called when the {@link Handler} (or it's delegates) fail the request handling.
+         *
          * @param failure The reason for the failure.
          */
         @Override
@@ -1656,6 +1660,7 @@ public void succeeded()
 
         /**
          * Called when the error write in {@link HttpChannelState.ChannelCallback#failed(Throwable)} fails.
+         *
          * @param x The reason for the failure.
          */
         @Override

jetty-core/jetty-util/src/main/java/org/eclipse/jetty/util/thread/AutoLock.java

@@ -13,6 +13,7 @@
 
 package org.eclipse.jetty.util.thread;
 
+import java.io.Serial;
 import java.io.Serializable;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.Condition;
@@ -30,6 +31,7 @@
  */
 public class AutoLock implements AutoCloseable, Serializable
 {
+    @Serial
     private static final long serialVersionUID = 3300696774541816341L;
 
     private final ReentrantLock _lock = new ReentrantLock();
@@ -46,8 +48,24 @@ public AutoLock lock()
     }
 
     /**
-     * @see ReentrantLock#isHeldByCurrentThread()
+     * <p>Tries to acquire the lock.</p>
+     * <p>Whether the lock was acquired can be tested
+     * with {@link #isHeldByCurrentThread()}.</p>
+     * <p>Typical usage of this method is in {@code toString()},
+     * to avoid deadlocks when the implementation needs to lock
+     * to retrieve a consistent state to produce the string.</p>
+     *
+     * @return this AutoLock for unlocking
+     */
+    public AutoLock tryLock()
+    {
+        _lock.tryLock();
+        return this;
+    }
+
+    /**
      * @return whether this lock is held by the current thread
+     * @see ReentrantLock#isHeldByCurrentThread()
      */
     public boolean isHeldByCurrentThread()
     {
@@ -71,7 +89,8 @@ boolean isLocked()
     @Override
     public void close()
     {
-        _lock.unlock();
+        if (isHeldByCurrentThread())
+            _lock.unlock();
     }
 
     /**
@@ -101,6 +120,12 @@ public AutoLock.WithCondition lock()
             return (WithCondition)super.lock();
         }
 
+        @Override
+        public AutoLock.WithCondition tryLock()
+        {
+            return (WithCondition)super.tryLock();
+        }
+
         /**
          * @see Condition#signal()
          */
@@ -118,20 +143,20 @@ public void signalAll()
         }
 
         /**
-         * @see Condition#await()
          * @throws InterruptedException if the current thread is interrupted
+         * @see Condition#await()
          */
         public void await() throws InterruptedException
         {
             _condition.await();
         }
 
         /**
-         * @see Condition#await(long, TimeUnit)
          * @param time the time to wait
          * @param unit the time unit
          * @return false if the waiting time elapsed
          * @throws InterruptedException if the current thread is interrupted
+         * @see Condition#await(long, TimeUnit)
          */
         public boolean await(long time, TimeUnit unit) throws InterruptedException
         {