import java.lang.reflect.Field;  
import java.util.List;  
import java.util.concurrent.*;  
  
public class ThreadPoolInfo {  
  
    public static void main(String[] args) throws InterruptedException {  
        // 創(chuàng)建一個(gè)固定大小的線程池  
        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(3);  
  
        // 提交一些任務(wù)給線程池  
        for (int i = 0; i < 5; i++) {  
            executor.submit(() -> {  
                try {  
                    Thread.sleep(2000); // 模擬任務(wù)執(zhí)行  
                    System.out.println(Thread.currentThread().getName() + " is executing a task.");  
                } catch (InterruptedException e) {  
                    Thread.currentThread().interrupt();  
                }  
            });  
        }  
  
        // 等待一段時(shí)間以確保任務(wù)開始執(zhí)行  
        Thread.sleep(1000);  
  
        // 獲取線程池中的線程列表  
        List<Thread> threadList = getThreadPoolThreads(executor);  
  
        // 打印線程信息  
        for (Thread thread : threadList) {  
            System.out.println("Thread: " + thread.getName() + ", State: " + thread.getState());  
        }  
  
        // 關(guān)閉線程池  
        executor.shutdown();  
        executor.awaitTermination(1, TimeUnit.MINUTES);  
    }  
  
    /**  
     * 通過反射獲取線程池中的線程列表  
     *  
     * @param executor 線程池執(zhí)行器  
     * @return 線程列表  
     */  
    public static List<Thread> getThreadPoolThreads(ThreadPoolExecutor executor) {  
        List<Thread> threadList = null;  
        try {  
            // 獲取workerQueue字段（這是一個(gè)阻塞隊(duì)列，存儲(chǔ)等待執(zhí)行的任務(wù)）  
            Field workerQueueField = ThreadPoolExecutor.class.getDeclaredField("workerQueue");  
            workerQueueField.setAccessible(true);  
            BlockingQueue<?> workerQueue = (BlockingQueue<?>) workerQueueField.get(executor);  
  
            // 獲取mainLock字段（這是一個(gè)ReentrantLock，用于同步對(duì)workerSet的訪問）  
            Field mainLockField = ThreadPoolExecutor.class.getDeclaredField("mainLock");  
            mainLockField.setAccessible(true);  
            ReentrantLock mainLock = (ReentrantLock) mainLockField.get(executor);  
  
            // 獲取workerSet字段（這是一個(gè)HashSet，存儲(chǔ)所有的Worker對(duì)象）  
            Field workerSetField = ThreadPoolExecutor.class.getDeclaredField("workers");  
            workerSetField.setAccessible(true);  
            HashSet<?> workerSet = (HashSet<?>) workerSetField.get(executor);  
  
            // 鎖定mainLock以確保對(duì)workerSet的訪問是線程安全的  
            mainLock.lock();  
            try {  
                // 創(chuàng)建一個(gè)線程列表來存儲(chǔ)所有的線程  
                threadList = new ArrayList<>();  
                // 遍歷workerSet，獲取每個(gè)Worker對(duì)象的線程  
                for (Object worker : workerSet) {  
                    Field threadField = worker.getClass().getDeclaredField("thread");  
                    threadField.setAccessible(true);  
                    Thread thread = (Thread) threadField.get(worker);  
                    threadList.add(thread);  
                }  
            } finally {  
                // 釋放鎖  
                mainLock.unlock();  
            }  
        } catch (NoSuchFieldException | IllegalAccessException e) {  
            e.printStackTrace();  
        }  
  
        // 如果workerQueue中有等待執(zhí)行的任務(wù)，那么這些任務(wù)對(duì)應(yīng)的線程可能還沒有啟動(dòng)，因此這里不考慮它們  
        // 如果需要獲取這些任務(wù)的信息，可以遍歷workerQueue  
  
        return threadList;  
    }  
}

Set<Thread> allThreads = Thread.getAllStackTraces().keySet();  
// 遍歷allThreads，檢查每個(gè)線程是否屬于我們的線程池

import java.util.Map;  
import java.util.Set;  
  
public class ThreadPoolThreadChecker {  
    public static void main(String[] args) {  
        // 假設(shè)我們有一個(gè)線程池在運(yùn)行（這里不實(shí)際創(chuàng)建）  
        // ...  
  
        // 獲取所有線程的堆棧軌跡映射  
        Map<Thread, StackTraceElement[]> allStackTraces = Thread.getAllStackTraces();  
        Set<Thread> allThreads = allStackTraces.keySet();  
  
        // 遍歷所有線程，檢查它們是否屬于某個(gè)線程池  
        // 這里假設(shè)線程池中的線程名稱包含特定的字符串，比如 "myThreadPool-"  
        for (Thread thread : allThreads) {  
            if (thread.getName().contains("myThreadPool-")) {  
                System.out.println("Found thread from thread pool: " + thread.getName());  
                // 我們可以在這里添加更多邏輯來處理這些線程  
            }  
        }  
    }  
}

import java.util.concurrent.*;  
  
public class ThreadPoolStatusChecker {  
    public static void main(String[] args) {  
        // 創(chuàng)建一個(gè)線程池  
        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(4);  
  
        // 提交一些任務(wù)給線程池（這里只是示例）  
        for (int i = 0; i < 10; i++) {  
            executor.submit(() -> {  
                try {  
                    Thread.sleep(1000); // 模擬任務(wù)執(zhí)行  
                } catch (InterruptedException e) {  
                    Thread.currentThread().interrupt();  
                }  
            });  
        }  
  
        // 獲取線程池的狀態(tài)信息  
        System.out.println("Active threads: " + executor.getActiveCount());  
        System.out.println("Completed tasks: " + executor.getCompletedTaskCount());  
        System.out.println("Total tasks: " + (executor.getCompletedTaskCount() + executor.getTaskCount()));  
  
        // 關(guān)閉線程池（這里只是為了示例，實(shí)際使用中應(yīng)該等待所有任務(wù)完成后再關(guān)閉）  
        executor.shutdownNow();  
    }  
}

import java.util.ArrayList;  
import java.util.List;  
import java.util.concurrent.*;  
  
public class CustomThreadFactory implements ThreadFactory {  
    private final String namePrefix;  
    private final List<Thread> createdThreads = new ArrayList<>();  
    private int threadNumber = 1;  
  
    public CustomThreadFactory(String namePrefix) {  
        this.namePrefix = namePrefix;  
    }  
  
    @Override  
    public Thread newThread(Runnable r) {  
        Thread thread = new Thread(r, namePrefix + "-Thread-" + threadNumber);  
        createdThreads.add(thread);  
        threadNumber++;  
        return thread;  
    }  
  
    public List<Thread> getCreatedThreads() {  
        return createdThreads;  
    }  
  
    public static void main(String[] args) {  
        CustomThreadFactory factory = new CustomThreadFactory("MyThreadPool");  
        ThreadPoolExecutor executor = new ThreadPoolExecutor(  
                2, 4, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), factory);  
  
        // 提交任務(wù)（這里只是示例）  
        for (int i = 0; i < 5; i++) {  
            executor.submit(() -> {  
                try {  
                    Thread.sleep(1000); // 模擬任務(wù)執(zhí)行  
                } catch (InterruptedException e) {  
                    Thread.currentThread().interrupt();  
                }  
            });  
        }  
  
        // 獲取自定義工廠中創(chuàng)建的線程列表  
        List<Thread> threads = factory.getCreatedThreads();  
        for (Thread thread : threads) {  
            System.out.println("Created thread: " + thread.getName());  
        }  
  
        // 關(guān)閉線程池（這里只是為了示例，實(shí)際使用中應(yīng)該等待所有任務(wù)完成后再關(guān)閉）  
        executor.shutdownNow();  
    }  
}

import javax.management.*;  
import java.lang.management.*;  
import java.util.Set;  
  
public class JmxThreadPoolMonitor {  
    public static void main(String[] args) throws Exception {  
        // 獲取平臺(tái)MBean服務(wù)器  
        MBeanServer mbeanServer = ManagementFactory.getPlatformMBeanServer();  
  
        // 查詢線程池相關(guān)的MBean（這里需要知道具體的ObjectName）  
        // 例如，對(duì)于Java EE應(yīng)用服務(wù)器，ObjectName可能會(huì)有所不同  
        // 這里只是一個(gè)假設(shè)的ObjectName，我們需要根據(jù)實(shí)際情況進(jìn)行修改  
        ObjectName query = new ObjectName("java.util.concurrent:type=ThreadPool,name=*");  
  
        // 執(zhí)行查詢  
        Set<ObjectName> names = mbeanServer.queryNames(query, null);  
  
        // 遍歷查詢結(jié)果  
        for (ObjectName name : names) {  
            // 獲取線程池的屬性（這里只是示例，我們可以獲取更多屬性）  
            Integer activeCount = (Integer) mbeanServer.getAttribute(name, "ActiveCount");  
            Long completedTaskCount = (Long) mbeanServer.getAttribute(name, "CompletedTaskCount");  
  
            System.out.println("ThreadPool Name: " + name.getKeyProperty("name"));  
            System.out.println("Active Threads: " + activeCount);  
            System.out.println("Completed Tasks: " + completedTaskCount);  
        }  
    }  
}