diff --git a/src/main/java/org/redkale/util/Utility.java b/src/main/java/org/redkale/util/Utility.java
index 416d22244..afa204a63 100644
--- a/src/main/java/org/redkale/util/Utility.java
+++ b/src/main/java/org/redkale/util/Utility.java
@@ -118,6 +118,7 @@ public final class Utility {
 
     // private static final javax.net.ssl.SSLContext DEFAULTSSL_CONTEXT;
     // private static final javax.net.ssl.HostnameVerifier defaultVerifier = (s, ss) -> true;
+    //
     static {
         System.setProperty("jdk.httpclient.allowRestrictedHeaders", "host");
 
@@ -139,68 +140,65 @@ public final class Utility {
         Function<Supplier, ThreadLocal> virtualThreadLocalFunction0 = null;
         Function<String, ThreadFactory> virtualThreadFactoryFunction0 = null;
 
-        //if (!NATIVE_IMAGE_ENV) { // not native-image
+        final ClassLoader loader = Thread.currentThread().getContextClassLoader();
+        { // Jdk21Inners
             try {
-                final ClassLoader loader = Thread.currentThread().getContextClassLoader();
-                { // Jdk21Inners
-                    try {
-                        String virtualName = "org.redkale.util.Jdk21Inners";
-                        Class virtualClazz = loader.loadClass(virtualName);
-                        Method method = virtualClazz.getMethod("createExecutor");
-                        virtualExecutorConsumer0 = (Executor) method.invoke(null);
-                        RedkaleClassLoader.putReflectionMethod(virtualName, method);
+                String virtualName = "org.redkale.util.Jdk21Inners";
+                Class virtualClazz = loader.loadClass(virtualName);
+                Method method = virtualClazz.getMethod("createExecutor");
+                virtualExecutorConsumer0 = (Executor) method.invoke(null);
+                RedkaleClassLoader.putReflectionMethod(virtualName, method);
 
-                        method = virtualClazz.getMethod("createPoolFunction");
-                        virtualPoolFunction0 = (Function) method.invoke(null);
-                        RedkaleClassLoader.putReflectionMethod(virtualName, method);
+                method = virtualClazz.getMethod("createPoolFunction");
+                virtualPoolFunction0 = (Function) method.invoke(null);
+                RedkaleClassLoader.putReflectionMethod(virtualName, method);
 
-                        method = virtualClazz.getMethod("createThreadLocalFunction");
-                        virtualThreadLocalFunction0 = (Function) method.invoke(null);
-                        RedkaleClassLoader.putReflectionMethod(virtualName, method);
+                method = virtualClazz.getMethod("createThreadLocalFunction");
+                virtualThreadLocalFunction0 = (Function) method.invoke(null);
+                RedkaleClassLoader.putReflectionMethod(virtualName, method);
 
-                        method = virtualClazz.getMethod("createThreadFactoryFunction");
-                        virtualThreadFactoryFunction0 = (Function) method.invoke(null);
-                        RedkaleClassLoader.putReflectionMethod(virtualName, method);
-                    } catch (Throwable t) {
-                        // do nothing
-                    }
-                }
-                { // String-LATIN1
-                    MethodHandles.Lookup lookup = defaultLookup;
-                    VarHandle compactHandle = lookup.findVarHandle(String.class, "COMPACT_STRINGS", boolean.class);
-                    final boolean compact = (Boolean) compactHandle.get(null);
-                    VarHandle coderHandle = lookup.findVarHandle(String.class, "coder", byte.class);
-                    VarHandle valueHandle = lookup.findVarHandle(String.class, "value", byte[].class);
-                    // LATIN1:0  UTF16:1
-                    strLatin1Function0 = compact ? (String t) -> (Byte) coderHandle.get(t) == 0 : (String t) -> false;
-                    strByteFunction0 = (String t) -> (byte[]) valueHandle.get(t);
-                }
-                { // signalShutdown
-                    Class<Consumer<Consumer<String>>> shutdownClazz1 = null;
-                    try {
-                        shutdownClazz1 = (Class) loader.loadClass("org.redkale.util.SignalShutDown");
-                    } catch (Throwable t) {
-                        // do nothing
-                    }
-                    if (shutdownClazz1 == null) {
-                        byte[] classBytes = hexToBin(consumerSignalShutdownBinary);
-                        shutdownClazz1 = (Class<Consumer<Consumer<String>>>)
-                                new ClassLoader(loader) {
-                                    public final Class<?> loadClass(String name, byte[] b) {
-                                        return defineClass(name, b, 0, b.length);
-                                    }
-                                }.loadClass("org.redkale.util.SignalShutDown", classBytes);
-                        RedkaleClassLoader.putDynClass(shutdownClazz1.getName(), classBytes, shutdownClazz1);
-                        RedkaleClassLoader.putReflectionDeclaredConstructors(shutdownClazz1, shutdownClazz1.getName());
-                        signalShutdownConsumer0 =
-                                shutdownClazz1.getConstructor().newInstance();
-                    }
-                }
-            } catch (Throwable e) { // 不会发生
+                method = virtualClazz.getMethod("createThreadFactoryFunction");
+                virtualThreadFactoryFunction0 = (Function) method.invoke(null);
+                RedkaleClassLoader.putReflectionMethod(virtualName, method);
+            } catch (Throwable t) {
                 // do nothing
-                e.printStackTrace();
             }
-        //}
+        }
+        try {
+            { // String-LATIN1
+                MethodHandles.Lookup lookup = defaultLookup;
+                VarHandle compactHandle = lookup.findStaticVarHandle(String.class, "COMPACT_STRINGS", boolean.class);
+                final boolean compact = (Boolean) compactHandle.get(null);
+                VarHandle coderHandle = lookup.findVarHandle(String.class, "coder", byte.class);
+                VarHandle valueHandle = lookup.findVarHandle(String.class, "value", byte[].class);
+                // LATIN1:0  UTF16:1
+                strLatin1Function0 = compact ? (String t) -> (Byte) coderHandle.get(t) == 0 : (String t) -> false;
+                strByteFunction0 = (String t) -> (byte[]) valueHandle.get(t);
+            }
+            { // signalShutdown
+                Class<Consumer<Consumer<String>>> shutdownClazz1 = null;
+                try {
+                    shutdownClazz1 = (Class) loader.loadClass("org.redkale.util.SignalShutDown");
+                } catch (Throwable t) {
+                    // do nothing
+                }
+                if (shutdownClazz1 == null) {
+                    byte[] classBytes = hexToBin(consumerSignalShutdownBinary);
+                    shutdownClazz1 = (Class<Consumer<Consumer<String>>>)
+                            new ClassLoader(loader) {
+                                public final Class<?> loadClass(String name, byte[] b) {
+                                    return defineClass(name, b, 0, b.length);
+                                }
+                            }.loadClass("org.redkale.util.SignalShutDown", classBytes);
+                    RedkaleClassLoader.putDynClass(shutdownClazz1.getName(), classBytes, shutdownClazz1);
+                    RedkaleClassLoader.putReflectionDeclaredConstructors(shutdownClazz1, shutdownClazz1.getName());
+                    signalShutdownConsumer0 = shutdownClazz1.getConstructor().newInstance();
+                }
+            }
+        } catch (Throwable e) { // 不会发生
+            // do nothing
+            e.printStackTrace();
+        }
         strByteFunction = strByteFunction0;
         strLatin1Function = strLatin1Function0;
         signalShutdownConsumer = signalShutdownConsumer0;