diff --git a/spring-boot-hello/src/main/java/com/neo/config/NamingThreadFactory.java b/spring-boot-hello/src/main/java/com/neo/config/NamingThreadFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..c0e4fbb90389c4a62e772b12af2720844761176a
--- /dev/null
+++ b/spring-boot-hello/src/main/java/com/neo/config/NamingThreadFactory.java
@@ -0,0 +1,31 @@
+package com.neo.config;
+
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicInteger;
+/**
+ * 线程工厂，它设置线程名称，有利于我们定位问题。
+ */
+public final class NamingThreadFactory implements ThreadFactory {
+
+    private final AtomicInteger threadNum = new AtomicInteger();
+    private final ThreadFactory delegate;
+    private final String name;
+
+    /**
+     * 创建一个带名字的线程池生产工厂
+     */
+    public NamingThreadFactory(ThreadFactory delegate, String name) {
+        this.delegate = delegate;
+        this.name = name; // TODO consider uniquifying this
+    }
+
+    @Override
+    public Thread newThread(Runnable r) {
+        Thread t = delegate.newThread(r);
+        t.setName(name + " [#" + threadNum.incrementAndGet() + "]");
+        return t;
+    }
+
+}
diff --git a/spring-boot-hello/src/test/java/com/neo/TreadPoolMain.java b/spring-boot-hello/src/test/java/com/neo/TreadPoolMain.java
new file mode 100644
index 0000000000000000000000000000000000000000..fa5176cf336b81788122ebce7d7b871752d0d8ae
--- /dev/null
+++ b/spring-boot-hello/src/test/java/com/neo/TreadPoolMain.java
@@ -0,0 +1,82 @@
+package com.neo;
+
+
+import com.neo.config.NamingThreadFactory;
+import org.junit.Test;
+
+import java.time.Instant;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @program: spring-boot-examples
+ * @description:
+ * @author: RLWater
+ * @create: 2022-12-16 15:27
+ **/
+public class TreadPoolMain {
+
+
+    private static final int CORE_POOL_SIZE = 5;
+    private static final int MAX_POOL_SIZE = 10;
+    private static final int QUEUE_CAPACITY = 100; // 当前线程数>CORE_POOL_SIZE+QUEUE_CAPACITY时，再判断<MAX_POOL_SIZE后根据KEEP_ALIVE_TIME时间判断是否需要丢弃
+    private static final Long KEEP_ALIVE_TIME = 4L; //当线程数大于核心线程数时，多余的空闲线程存活的最长时间
+
+    @Test
+    public void main() {
+
+
+        //使用阿里巴巴推荐的创建线程池的方式
+        //通过ThreadPoolExecutor构造函数自定义参数创建
+        ThreadPoolExecutor executor = new ThreadPoolExecutor(
+                CORE_POOL_SIZE,
+                MAX_POOL_SIZE,
+                KEEP_ALIVE_TIME,
+                TimeUnit.SECONDS,
+                new ArrayBlockingQueue<>(QUEUE_CAPACITY),
+                new ThreadPoolExecutor.CallerRunsPolicy());
+
+        ThreadPoolExecutor executor2 = new ThreadPoolExecutor(
+                CORE_POOL_SIZE,
+                MAX_POOL_SIZE,
+                KEEP_ALIVE_TIME,
+                TimeUnit.SECONDS,
+                new ArrayBlockingQueue<>(QUEUE_CAPACITY),
+                new ThreadPoolExecutor.CallerRunsPolicy());
+
+        for (int i = 0; i < 10; i++) {
+            executor.execute(() -> {
+                //try {
+                //    Thread.sleep(2000);
+                //    //executor2.execute(() -> {
+                //    //    try {
+                //    //        Thread.sleep(2000);
+                //    //    }catch (InterruptedException e){
+                //    //        e.printStackTrace();
+                //    //    }
+                //    //});
+                //} catch (InterruptedException e) {
+                //    e.printStackTrace();
+                //}
+                for (int j=0; j<10; j++){
+                    executor2.execute(() -> {
+                        System.out.println("CurrentThread name:" + Thread.currentThread().getName());
+                        System.out.println("hello");
+                    });
+                }
+
+                System.out.println("CurrentThread name:" + Thread.currentThread().getName() + "date：" + Instant.now());
+            });
+        }
+        //终止线程池
+        executor.shutdown();
+        try {
+            executor.awaitTermination(5, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        System.out.println("Finished all threads");
+    }
+
+}