diff --git a/jetcache-core/src/main/java/com/alicp/jetcache/support/JavaValueEncoder.java b/jetcache-core/src/main/java/com/alicp/jetcache/support/JavaValueEncoder.java index dcd483f39..6794d3676 100644 --- a/jetcache-core/src/main/java/com/alicp/jetcache/support/JavaValueEncoder.java +++ b/jetcache-core/src/main/java/com/alicp/jetcache/support/JavaValueEncoder.java @@ -16,45 +16,46 @@ public class JavaValueEncoder extends AbstractValueEncoder { public static final JavaValueEncoder INSTANCE = new JavaValueEncoder(true); - private static final int INIT_BUF_SIZE = 256; + private static final int INIT_BUF_SIZE = 2048; public JavaValueEncoder(boolean useIdentityNumber) { super(useIdentityNumber); } - private static ThreadLocal> threadLocal = - ThreadLocal.withInitial(() -> new WeakReference<>(new ByteArrayOutputStream(INIT_BUF_SIZE))); + static ObjectPool bosPool = new ObjectPool<>(16, new ObjectPool.ObjectFactory() { + @Override + public ByteArrayOutputStream create() { + return new ByteArrayOutputStream(INIT_BUF_SIZE); + } + + @Override + public void reset(ByteArrayOutputStream obj) { + obj.reset(); + } + }); @Override public byte[] apply(Object value) { + ByteArrayOutputStream bos = null; try { - WeakReference ref = threadLocal.get(); - ByteArrayOutputStream bos = ref.get(); - if (bos == null) { - bos = new ByteArrayOutputStream(INIT_BUF_SIZE); - threadLocal.set(new WeakReference<>(bos)); - } - - try { - if (useIdentityNumber) { - bos.write((SerialPolicy.IDENTITY_NUMBER_JAVA >> 24) & 0xFF); - bos.write((SerialPolicy.IDENTITY_NUMBER_JAVA >> 16) & 0xFF); - bos.write((SerialPolicy.IDENTITY_NUMBER_JAVA >> 8) & 0xFF); - bos.write(SerialPolicy.IDENTITY_NUMBER_JAVA & 0xFF); - } - - - ObjectOutputStream oos = new ObjectOutputStream(bos); - oos.writeObject(value); - oos.flush(); - return bos.toByteArray(); - } finally { - bos.reset(); + bos = bosPool.borrowObject(); + if (useIdentityNumber) { + bos.write((SerialPolicy.IDENTITY_NUMBER_JAVA >> 24) & 0xFF); + bos.write((SerialPolicy.IDENTITY_NUMBER_JAVA >> 16) & 0xFF); + bos.write((SerialPolicy.IDENTITY_NUMBER_JAVA >> 8) & 0xFF); + bos.write(SerialPolicy.IDENTITY_NUMBER_JAVA & 0xFF); } + ObjectOutputStream oos = new ObjectOutputStream(bos); + oos.writeObject(value); + oos.flush(); + return bos.toByteArray(); } catch (IOException e) { StringBuilder sb = new StringBuilder("Java Encode error. "); sb.append("msg=").append(e.getMessage()); throw new CacheEncodeException(sb.toString(), e); + }finally { + if(bos != null) + bosPool.returnObject(bos); } } } diff --git a/jetcache-core/src/main/java/com/alicp/jetcache/support/Kryo5ValueDecoder.java b/jetcache-core/src/main/java/com/alicp/jetcache/support/Kryo5ValueDecoder.java index 12924b886..b549a20c2 100644 --- a/jetcache-core/src/main/java/com/alicp/jetcache/support/Kryo5ValueDecoder.java +++ b/jetcache-core/src/main/java/com/alicp/jetcache/support/Kryo5ValueDecoder.java @@ -27,16 +27,24 @@ public Object doApply(byte[] buffer) { in = new ByteArrayInputStream(buffer); } Input input = new Input(in); - Kryo kryo = (Kryo) Kryo5ValueEncoder.kryoThreadLocal.get()[0]; - ClassLoader classLoader = Kryo5ValueDecoder.class.getClassLoader(); - Thread t = Thread.currentThread(); - if (t != null) { - ClassLoader ctxClassLoader = t.getContextClassLoader(); - if (ctxClassLoader != null) { - classLoader = ctxClassLoader; + Kryo5ValueEncoder.Kryo5Cache kryoCache = null; + try { + kryoCache = Kryo5ValueEncoder.kryoCacheObjectPool.borrowObject(); + Kryo kryo = kryoCache.getKryo(); + ClassLoader classLoader = Kryo5ValueDecoder.class.getClassLoader(); + Thread t = Thread.currentThread(); + if (t != null) { + ClassLoader ctxClassLoader = t.getContextClassLoader(); + if (ctxClassLoader != null) { + classLoader = ctxClassLoader; + } + } + kryo.setClassLoader(classLoader); + return kryo.readClassAndObject(input); + }finally { + if(kryoCache != null){ + Kryo5ValueEncoder.kryoCacheObjectPool.returnObject(kryoCache); } } - kryo.setClassLoader(classLoader); - return kryo.readClassAndObject(input); } } diff --git a/jetcache-core/src/main/java/com/alicp/jetcache/support/Kryo5ValueEncoder.java b/jetcache-core/src/main/java/com/alicp/jetcache/support/Kryo5ValueEncoder.java index 8f7279eba..05e334266 100644 --- a/jetcache-core/src/main/java/com/alicp/jetcache/support/Kryo5ValueEncoder.java +++ b/jetcache-core/src/main/java/com/alicp/jetcache/support/Kryo5ValueEncoder.java @@ -5,8 +5,6 @@ import com.esotericsoftware.kryo.kryo5.io.Output; import com.esotericsoftware.kryo.kryo5.serializers.CompatibleFieldSerializer; -import java.lang.ref.WeakReference; - /** * Created on 2016/10/4. * @@ -16,53 +14,63 @@ public class Kryo5ValueEncoder extends AbstractValueEncoder { public static final Kryo5ValueEncoder INSTANCE = new Kryo5ValueEncoder(true); - private static int INIT_BUFFER_SIZE = 256; - - static ThreadLocal kryoThreadLocal = ThreadLocal.withInitial(() -> { - Kryo kryo = new Kryo(); - kryo.setDefaultSerializer(CompatibleFieldSerializer.class); - kryo.setRegistrationRequired(false); + private static final int INIT_BUFFER_SIZE = 2048; - Output output = new Output(INIT_BUFFER_SIZE, -1); + //Default size = 32K + static ObjectPool kryoCacheObjectPool = new ObjectPool<>(16, new ObjectPool.ObjectFactory() { + @Override + public Kryo5Cache create() { + return new Kryo5Cache(); + } - WeakReference ref = new WeakReference<>(output); - return new Object[]{kryo, ref}; + @Override + public void reset(Kryo5Cache obj) { + obj.getKryo().reset(); + obj.getOutput().reset(); + } }); + public static class Kryo5Cache { + final Output output; + final Kryo kryo; + public Kryo5Cache(){ + kryo = new Kryo(); + kryo.setDefaultSerializer(CompatibleFieldSerializer.class); + kryo.setRegistrationRequired(false); + output = new Output(INIT_BUFFER_SIZE, -1); + } + + public Output getOutput(){ + return output; + } + + public Kryo getKryo(){ + return kryo; + } + + } + public Kryo5ValueEncoder(boolean useIdentityNumber) { super(useIdentityNumber); } @Override public byte[] apply(Object value) { + Kryo5Cache kryoCache = null; try { - Object[] kryoAndBuffer = kryoThreadLocal.get(); - Kryo kryo = (Kryo) kryoAndBuffer[0]; - WeakReference ref = (WeakReference) kryoAndBuffer[1]; - Output output = ref.get(); - if (output == null) { - output = new Output(INIT_BUFFER_SIZE, -1); - } - - try { - if (useIdentityNumber) { - writeInt(output, SerialPolicy.IDENTITY_NUMBER_KRYO5); - } - kryo.reset(); - kryo.writeClassAndObject(output, value); - return output.toBytes(); - } finally { - //reuse buffer if possible - output.reset(); - if (ref.get() == null) { - ref = new WeakReference<>(output); - kryoAndBuffer[1] = ref; - } + kryoCache = kryoCacheObjectPool.borrowObject(); + if (useIdentityNumber) { + writeInt(kryoCache.getOutput(), SerialPolicy.IDENTITY_NUMBER_KRYO5); } + kryoCache.getKryo().writeClassAndObject(kryoCache.getOutput(), value); + return kryoCache.getOutput().toBytes(); } catch (Exception e) { StringBuilder sb = new StringBuilder("Kryo Encode error. "); sb.append("msg=").append(e.getMessage()); throw new CacheEncodeException(sb.toString(), e); + }finally { + if(kryoCache != null) + kryoCacheObjectPool.returnObject(kryoCache); } } diff --git a/jetcache-core/src/main/java/com/alicp/jetcache/support/KryoValueDecoder.java b/jetcache-core/src/main/java/com/alicp/jetcache/support/KryoValueDecoder.java index fc5705e93..db8c8449a 100644 --- a/jetcache-core/src/main/java/com/alicp/jetcache/support/KryoValueDecoder.java +++ b/jetcache-core/src/main/java/com/alicp/jetcache/support/KryoValueDecoder.java @@ -27,16 +27,24 @@ public Object doApply(byte[] buffer) { in = new ByteArrayInputStream(buffer); } Input input = new Input(in); - Kryo kryo = (Kryo) KryoValueEncoder.kryoThreadLocal.get()[0]; - ClassLoader classLoader = KryoValueDecoder.class.getClassLoader(); - Thread t = Thread.currentThread(); - if (t != null) { - ClassLoader ctxClassLoader = t.getContextClassLoader(); - if (ctxClassLoader != null) { - classLoader = ctxClassLoader; + KryoValueEncoder.KryoCache kryoCache = null; + try { + kryoCache = KryoValueEncoder.kryoCacheObjectPool.borrowObject(); + Kryo kryo = kryoCache.getKryo(); + ClassLoader classLoader = KryoValueDecoder.class.getClassLoader(); + Thread t = Thread.currentThread(); + if (t != null) { + ClassLoader ctxClassLoader = t.getContextClassLoader(); + if (ctxClassLoader != null) { + classLoader = ctxClassLoader; + } + } + kryo.setClassLoader(classLoader); + return kryo.readClassAndObject(input); + }finally { + if(kryoCache != null){ + KryoValueEncoder.kryoCacheObjectPool.returnObject(kryoCache); } } - kryo.setClassLoader(classLoader); - return kryo.readClassAndObject(input); } } diff --git a/jetcache-core/src/main/java/com/alicp/jetcache/support/KryoValueEncoder.java b/jetcache-core/src/main/java/com/alicp/jetcache/support/KryoValueEncoder.java index c830108f0..13fbd1240 100644 --- a/jetcache-core/src/main/java/com/alicp/jetcache/support/KryoValueEncoder.java +++ b/jetcache-core/src/main/java/com/alicp/jetcache/support/KryoValueEncoder.java @@ -5,7 +5,7 @@ import com.esotericsoftware.kryo.io.Output; import com.esotericsoftware.kryo.serializers.CompatibleFieldSerializer; -import java.lang.ref.WeakReference; +import java.util.Arrays; /** * Created on 2016/10/4. @@ -16,53 +16,64 @@ public class KryoValueEncoder extends AbstractValueEncoder { public static final KryoValueEncoder INSTANCE = new KryoValueEncoder(true); - private static int INIT_BUFFER_SIZE = 256; + private static final int INIT_BUFFER_SIZE = 2048; - static ThreadLocal kryoThreadLocal = ThreadLocal.withInitial(() -> { - Kryo kryo = new Kryo(); - kryo.setDefaultSerializer(CompatibleFieldSerializer.class); -// kryo.setInstantiatorStrategy(new StdInstantiatorStrategy()); -// kryo.setInstantiatorStrategy(new Kryo.DefaultInstantiatorStrategy(new StdInstantiatorStrategy())); - - byte[] buffer = new byte[INIT_BUFFER_SIZE]; + //Default size = 32K + static ObjectPool kryoCacheObjectPool = new ObjectPool<>(16, new ObjectPool.ObjectFactory() { + @Override + public KryoCache create() { + return new KryoCache(); + } - WeakReference ref = new WeakReference<>(buffer); - return new Object[]{kryo, ref}; + @Override + public void reset(KryoCache obj) { + obj.getKryo().reset(); + obj.getOutput().clear(); + } }); + public static class KryoCache { + final Output output; + final Kryo kryo; + public KryoCache(){ + kryo = new Kryo(); + kryo.setDefaultSerializer(CompatibleFieldSerializer.class); + byte[] buffer = new byte[INIT_BUFFER_SIZE]; + output = new Output(buffer, -1); + } + + public Output getOutput(){ + return output; + } + public Kryo getKryo(){ + return kryo; + } + } + public KryoValueEncoder(boolean useIdentityNumber) { super(useIdentityNumber); } @Override public byte[] apply(Object value) { + KryoCache kryoCache = null; try { - Object[] kryoAndBuffer = kryoThreadLocal.get(); - Kryo kryo = (Kryo) kryoAndBuffer[0]; - WeakReference ref = (WeakReference) kryoAndBuffer[1]; - byte[] buffer = ref.get(); - if (buffer == null) { - buffer = new byte[INIT_BUFFER_SIZE]; - } - Output output = new Output(buffer, -1); - - try { - if (useIdentityNumber) { - writeInt(output, SerialPolicy.IDENTITY_NUMBER_KRYO4); - } - kryo.writeClassAndObject(output, value); - return output.toBytes(); - } finally { - //reuse buffer if possible - if (ref.get() == null || buffer != output.getBuffer()) { - ref = new WeakReference<>(output.getBuffer()); - kryoAndBuffer[1] = ref; - } + kryoCache = kryoCacheObjectPool.borrowObject(); +// Output output = new Output(kryoCache.getBuffer(), -1); +// output.clear(); + Output output = kryoCache.getOutput(); + if (useIdentityNumber) { + writeInt(output, SerialPolicy.IDENTITY_NUMBER_KRYO4); } + kryoCache.getKryo().writeClassAndObject(output, value); + return output.toBytes(); } catch (Exception e) { StringBuilder sb = new StringBuilder("Kryo Encode error. "); sb.append("msg=").append(e.getMessage()); throw new CacheEncodeException(sb.toString(), e); + } finally { + if(kryoCache != null) + kryoCacheObjectPool.returnObject(kryoCache); } } diff --git a/jetcache-core/src/main/java/com/alicp/jetcache/support/ObjectPool.java b/jetcache-core/src/main/java/com/alicp/jetcache/support/ObjectPool.java new file mode 100644 index 000000000..e7803a661 --- /dev/null +++ b/jetcache-core/src/main/java/com/alicp/jetcache/support/ObjectPool.java @@ -0,0 +1,50 @@ +package com.alicp.jetcache.support; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.concurrent.ArrayBlockingQueue; + +/** + * @Description + * @author: zhangtong + * @create: 2023/10/6 3:27 PM + */ +public class ObjectPool { + private final ArrayBlockingQueue queue; + private final int size; + private final ObjectFactory factory; + private static final Logger logger = LoggerFactory.getLogger(ObjectPool.class); + + public ObjectPool(int size, ObjectFactory factory) { + this.size = size; + this.factory = factory; + queue = new ArrayBlockingQueue<>(size); + for (int i = 0; i < size; i++) { + queue.add(factory.create()); + } + logger.debug("Init the object pool with size {}", size); + } + + public T borrowObject() { + T t = queue.poll(); + if(t == null) { + logger.debug("The pool is not enough, create a new object"); + return factory.create(); + } + return t; + } + + public void returnObject(T obj) { + if (obj == null) { + return; + } + factory.reset(obj); + queue.offer(obj); + } + + public interface ObjectFactory { + T create(); + void reset(T obj); + } +} diff --git a/jetcache-test/src/test/java/com/alicp/jetcache/VirtualThreadUtil.java b/jetcache-test/src/test/java/com/alicp/jetcache/VirtualThreadUtil.java new file mode 100644 index 000000000..27380d269 --- /dev/null +++ b/jetcache-test/src/test/java/com/alicp/jetcache/VirtualThreadUtil.java @@ -0,0 +1,33 @@ +package com.alicp.jetcache; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.cglib.core.ReflectUtils; + +import java.lang.reflect.Method; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.TimeUnit; + +/** + * @Description + * @author: zhangtong + * @create: 2023/10/5 11:44 AM + */ +public class VirtualThreadUtil { + + private static Logger logger = LoggerFactory.getLogger(VirtualThreadUtil.class); + public static ExecutorService createExecuteor(){ + ExecutorService executorService = null; + try { + Method method = ReflectUtils.findDeclaredMethod(java.util.concurrent.Executors.class, "newVirtualThreadPerTaskExecutor", new Class[]{}); + if (method != null) { + logger.info("Test Thread start with newVirtualThreadPerTaskExecutor(Virtual)"); + executorService = (ExecutorService) method.invoke(null); + } + }catch (Exception e){ + logger.warn("JDK version may < 19, The Test will be skip..."); + return null; + } + return executorService; + } +} diff --git a/jetcache-test/src/test/java/com/alicp/jetcache/anno/support/CacheContextTest.java b/jetcache-test/src/test/java/com/alicp/jetcache/anno/support/CacheContextTest.java index 9d10e553c..8697ae3cd 100644 --- a/jetcache-test/src/test/java/com/alicp/jetcache/anno/support/CacheContextTest.java +++ b/jetcache-test/src/test/java/com/alicp/jetcache/anno/support/CacheContextTest.java @@ -3,8 +3,15 @@ */ package com.alicp.jetcache.anno.support; +import com.alicp.jetcache.VirtualThreadUtil; import org.junit.Assert; import org.junit.Test; +import org.springframework.cglib.core.ReflectUtils; + +import java.lang.reflect.Method; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; /** * @author huangli diff --git a/jetcache-test/src/test/java/com/alicp/jetcache/embedded/LinkedHashMapCacheTest.java b/jetcache-test/src/test/java/com/alicp/jetcache/embedded/LinkedHashMapCacheTest.java index d19cf9e8c..0c10f8afe 100644 --- a/jetcache-test/src/test/java/com/alicp/jetcache/embedded/LinkedHashMapCacheTest.java +++ b/jetcache-test/src/test/java/com/alicp/jetcache/embedded/LinkedHashMapCacheTest.java @@ -6,6 +6,7 @@ import com.alicp.jetcache.Cache; import com.alicp.jetcache.CacheConfig; import com.alicp.jetcache.CacheResultCode; +import com.alicp.jetcache.VirtualThreadUtil; import org.junit.Assert; import org.junit.Test; import org.springframework.cglib.core.ReflectUtils; @@ -37,38 +38,30 @@ public void test() throws Exception { public void mutilTest() throws InterruptedException{ cache = EmbeddedCacheBuilder.createEmbeddedCacheBuilder() .buildFunc(getBuildFunc()).expireAfterWrite(5000, TimeUnit.MILLISECONDS).limit(10240).buildCache(); - ExecutorService executorService = null; - try { - Method method = ReflectUtils.findDeclaredMethod(java.util.concurrent.Executors.class, "newVirtualThreadPerTaskExecutor", new Class[]{}); - if (method != null) { - System.out.println("use newVirtualThreadPerTaskExecutor"); - executorService = (ExecutorService) method.invoke(null); - } else { - System.out.println("use newFixedThreadPool"); - executorService = Executors.newFixedThreadPool(3); - } - }catch (Exception e){ + ExecutorService executorService = VirtualThreadUtil.createExecuteor(); + if(executorService == null){ executorService = Executors.newFixedThreadPool(3); } - executorService.awaitTermination(10,TimeUnit.SECONDS); + executorService.submit(() -> { - for (int i = 0; i < 20480; i+=2) { + for (int i = 0; i < 1000; i+=2) { cache.putIfAbsent("K" + i, "V" + i); } }); executorService.submit(() -> { - for (int i = 1; i < 20480; i+=2) { + for (int i = 1; i < 1000; i+=2) { cache.remove("K" + i); } }); executorService.submit(() -> { - for (int i = 0; i < 20480; i++) { + for (int i = 0; i < 1000; i++) { Object value = cache.get("K" + i); if(!Objects.isNull(value)) Assert.assertEquals(("V"+i),value); } }); executorService.shutdown(); + executorService.awaitTermination(10,TimeUnit.SECONDS); } @Test diff --git a/jetcache-test/src/test/java/com/alicp/jetcache/support/AbstractEncoderTest.java b/jetcache-test/src/test/java/com/alicp/jetcache/support/AbstractEncoderTest.java index cbb6fd530..d79da6e70 100644 --- a/jetcache-test/src/test/java/com/alicp/jetcache/support/AbstractEncoderTest.java +++ b/jetcache-test/src/test/java/com/alicp/jetcache/support/AbstractEncoderTest.java @@ -1,6 +1,7 @@ package com.alicp.jetcache.support; import com.alicp.jetcache.CacheValueHolder; +import com.alicp.jetcache.VirtualThreadUtil; import java.util.ArrayList; import java.util.Arrays; @@ -10,6 +11,9 @@ import java.util.List; import java.util.Map; import java.util.Set; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; import java.util.function.Function; import static org.junit.jupiter.api.Assertions.assertArrayEquals; @@ -136,4 +140,24 @@ protected void writeHeader(byte[] buf, int header) { buf[2] = (byte) (header >> 8 & 0xFF); buf[3] = (byte) (header & 0xFF); } + + + public void testByThreadPool(boolean isVirtual, int core, int size, Runnable runnable) throws InterruptedException { + ExecutorService executorService = null; + if(isVirtual) { + executorService = VirtualThreadUtil.createExecuteor(); + }else if(core > 0) { + executorService = Executors.newFixedThreadPool(core); + } + if(executorService == null) { + return; + } + if(size <= 0) size = 100; + for (int i = 0; i < size; i++) { + executorService.submit(runnable); + } + executorService.shutdown(); + executorService.awaitTermination(5, TimeUnit.SECONDS); + } + } diff --git a/jetcache-test/src/test/java/com/alicp/jetcache/support/JavaEncoderTest.java b/jetcache-test/src/test/java/com/alicp/jetcache/support/JavaEncoderTest.java index 4e5f4e14c..a7fc39fd3 100644 --- a/jetcache-test/src/test/java/com/alicp/jetcache/support/JavaEncoderTest.java +++ b/jetcache-test/src/test/java/com/alicp/jetcache/support/JavaEncoderTest.java @@ -66,4 +66,25 @@ public void gcTest() { super.gcTest(); } + + @Test + public void testVirtualThreadPool() throws InterruptedException { + testByThreadPool(true,-1,100,this::test); + } + + @Test + public void testVirtualThreadGC() throws InterruptedException { + testByThreadPool(true,-1,100,this::gcTest); + } + + @Test + public void testFixThreadPool() throws InterruptedException { + testByThreadPool(false,3,100,this::test); + } + + @Test + public void testFixThreadGC() throws InterruptedException { + testByThreadPool(false,3,100,this::gcTest); + } + } diff --git a/jetcache-test/src/test/java/com/alicp/jetcache/support/Kryo5EncoderTest.java b/jetcache-test/src/test/java/com/alicp/jetcache/support/Kryo5EncoderTest.java index 18d0e29fb..f8154b749 100644 --- a/jetcache-test/src/test/java/com/alicp/jetcache/support/Kryo5EncoderTest.java +++ b/jetcache-test/src/test/java/com/alicp/jetcache/support/Kryo5EncoderTest.java @@ -11,6 +11,7 @@ * @author huangli */ public class Kryo5EncoderTest extends AbstractEncoderTest { + @Test public void test() { encoder = Kryo5ValueEncoder.INSTANCE; @@ -66,4 +67,24 @@ public void gcTest() { super.gcTest(); } + @Test + public void testVirtualThreadPool() throws InterruptedException { + testByThreadPool(true,-1,100,this::test); + } + + @Test + public void testVirtualThreadGC() throws InterruptedException { + testByThreadPool(true,-1,100,this::gcTest); + } + @Test + public void testFixThreadPool() throws InterruptedException { + testByThreadPool(false,3,100,this::test); + } + + @Test + public void testFixThreadGC() throws InterruptedException { + testByThreadPool(false,3,100,this::gcTest); + } + + } diff --git a/jetcache-test/src/test/java/com/alicp/jetcache/support/KryoEncoderTest.java b/jetcache-test/src/test/java/com/alicp/jetcache/support/KryoEncoderTest.java index 04ad53002..3fc3a76d0 100644 --- a/jetcache-test/src/test/java/com/alicp/jetcache/support/KryoEncoderTest.java +++ b/jetcache-test/src/test/java/com/alicp/jetcache/support/KryoEncoderTest.java @@ -1,8 +1,12 @@ package com.alicp.jetcache.support; +import com.alicp.jetcache.VirtualThreadUtil; import com.alicp.jetcache.anno.SerialPolicy; import org.junit.jupiter.api.Test; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.TimeUnit; + import static org.junit.jupiter.api.Assertions.assertThrows; /** @@ -66,4 +70,25 @@ public void gcTest() { super.gcTest(); } + + @Test + public void testVirtualThreadPool() throws InterruptedException { + testByThreadPool(true,-1,100,this::test); + } + + @Test + public void testVirtualThreadGC() throws InterruptedException { + testByThreadPool(true,-1,100,this::gcTest); + } + + @Test + public void testFixThreadPool() throws InterruptedException { + testByThreadPool(false,3,100,this::test); + } + + @Test + public void testFixThreadGC() throws InterruptedException { + testByThreadPool(false,3,100,this::gcTest); + } + }