refactor: 优化close

Author: zhou-hao

hsweb-core/src/main/java/org/hswebframework/web/recycler/Recycler.java

@@ -161,6 +161,7 @@ default <A, A1, A2, A3, R> R doWith(A arg0, A1 arg1, A2 arg2, A3 arg3, Function5
      * <p>已借出的对象不在此方法内强制回收；它们后续调用 {@link Recyclable#recycle()} 时会被销毁而不是重新入池。
      */
     @Override
-    void close();
+    default void close() {
+    }
 
 }

hsweb-core/src/test/java/org/hswebframework/web/recycler/RecyclerImplTest.java

@@ -4,6 +4,8 @@
 import org.junit.Test;
 import reactor.core.scheduler.Schedulers;
 
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.BiFunction;
@@ -236,37 +238,36 @@ public void testStaticFactory() {
     }
 
     @Test
-    public void testStaticFactoryKeepsThreadLocalReuseForPlainObjects() {
+    public void testStaticFactoryKeepsThreadLocalReuseForPlainObjects() throws InterruptedException {
         Recycler<StringBuilder> recycler = Recycler.create(factory, rest, 2);
-
-        Integer created = Schedulers
-            .parallel()
-            .schedule(() -> {
-            }) == null ? null : null;
         AtomicReference<Integer> createdCount = new AtomicReference<>();
+        CountDownLatch latch = new CountDownLatch(1);
+
         Schedulers
             .parallel()
             .schedule(() -> {
-                recycler.doWith(sb -> {
-                    sb.append("first");
-                    return sb.toString();
-                });
-                recycler.doWith(sb -> {
-                    sb.append("second");
-                    return sb.toString();
-                });
-                createdCount.set(createCount.get());
+                try {
+                    recycler.doWith(sb -> {
+                        sb.append("first");
+                        return sb.toString();
+                    });
+                    recycler.doWith(sb -> {
+                        sb.append("second");
+                        return sb.toString();
+                    });
+                    createdCount.set(createCount.get());
+                } finally {
+                    latch.countDown();
+                }
             });
 
-        while (createdCount.get() == null) {
-            Thread.yield();
-        }
+        assertTrue(latch.await(5, TimeUnit.SECONDS));
 
         assertEquals(Integer.valueOf(1), createdCount.get());
     }
 
     @Test
-    public void testDestroyFactoryDoesNotUseThreadLocalForManagedResources() {
+    public void testDestroyFactoryDoesNotUseThreadLocalForManagedResources() throws InterruptedException {
         Recycler<TestResource> recycler = Recycler.create(
             TestResource::new,
             TestResource::reset,
@@ -275,25 +276,26 @@ public void testDestroyFactoryDoesNotUseThreadLocalForManagedResources() {
         );
         AtomicReference<TestResource> first = new AtomicReference<>();
         AtomicReference<TestResource> second = new AtomicReference<>();
-        AtomicReference<Boolean> complete = new AtomicReference<>();
+        CountDownLatch latch = new CountDownLatch(1);
 
         Schedulers
             .parallel()
             .schedule(() -> {
-                recycler.doWith(resource -> {
-                    first.set(resource);
-                    return resource.toString();
-                });
-                recycler.doWith(resource -> {
-                    second.set(resource);
-                    return resource.toString();
-                });
-                complete.set(Boolean.TRUE);
+                try {
+                    recycler.doWith(resource -> {
+                        first.set(resource);
+                        return resource.toString();
+                    });
+                    recycler.doWith(resource -> {
+                        second.set(resource);
+                        return resource.toString();
+                    });
+                } finally {
+                    latch.countDown();
+                }
             });
 
-        while (complete.get() == null) {
-            Thread.yield();
-        }
+        assertTrue(latch.await(5, TimeUnit.SECONDS));
 
         assertSame(first.get(), second.get());
         recycler.close();