每日学习Java之一万个为什么？

RunnableFuture接口实现类

线程池相关

自定义CPU密集线程池Demo

package com.qxy.practice.concurrent;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author : 戚欣扬
 * @Description :
 */
public class AutoIntegerDemo {

    public static void main(String[] args) {
        AtomicInteger autoInteger = new AtomicInteger(666);
        //定义一个标准CPU密集型设计线程池
        ExecutorService threadPoolExecutor = new ThreadPoolExecutor(
                Runtime.getRuntime().availableProcessors(),
                Runtime.getRuntime().availableProcessors()+1,
                1L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(6),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );
        System.out.println("I have "+Runtime.getRuntime().availableProcessors()+" processors");
        try {
            for (int i = 0; i < 5; i++) {
                threadPoolExecutor.execute(()->{
                    for (int j = 0; j < 20; j++) {
                        System.out.println(Thread.currentThread().getName()+" AInteger : "+autoInteger.incrementAndGet());
                    }
                });
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            threadPoolExecutor.shutdown();
        }

    }
}

AI定义拒绝策略 Demo

import java.util.concurrent.*;

public class AlibabaCustomRejectionHandler implements RejectedExecutionHandler {

    private static final Logger logger = LoggerFactory.getLogger(AlibabaCustomRejectionHandler.class);

    // 备用队列（可选，用于暂存被拒绝的任务）
    private final BlockingQueue<Runnable> backupQueue;

    public AlibabaCustomRejectionHandler(BlockingQueue<Runnable> backupQueue) {
        this.backupQueue = backupQueue;
    }

    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        // 1. 记录日志
        logRejection(r, executor);

        // 2. 尝试将任务存入备用队列
        if (backupQueue != null && !executor.isShutdown()) {
            try {
                backupQueue.put(r);
                logger.info("Task {} backed up to secondary queue", r);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                logger.error("Failed to backup task", e);
            }
        }

        // 3. 发送告警（可选，集成阿里云SLS或RocketMQ）
        sendAlert(r, executor);

        // 4. 降级策略：丢弃低优先级任务（示例）
        if (isLowPriorityTask(r)) {
            logger.warn("Discarded low-priority task: {}", r);
            return;
        }

        // 5. 如果以上均失败，抛出异常（可选）
        throw new RejectedExecutionException("Custom rejection policy failed for task: " + r);
    }

    private void logRejection(Runnable r, ThreadPoolExecutor executor) {
        logger.error(
            "Rejected task: {} | Pool Status: [Active={}, Core={}, Max={}, " +
            "QueueSize={}, CompletedTasks={}]", 
            r,
            executor.getActiveCount(),
            executor.getCorePoolSize(),
            executor.getMaximumPoolSize(),
            executor.getQueue().size(),
            executor.getCompletedTaskCount()
        );
    }

    private void sendAlert(Runnable r, ThreadPoolExecutor executor) {
        // 集成阿里云SLS或RocketMQ发送告警（此处为伪代码）
        // Example:
        // AlibabaCloudSLSClient.log("ThreadPoolRejection", 
        //     "Task=" + r + " | Pool=" + executor.toString());
    }

    private boolean isLowPriorityTask(Runnable r) {
        // 自定义逻辑判断任务优先级（例如：任务类名包含"LowPriority"）
        return r.getClass().getName().contains("LowPriority");
    }
}

线程池技术文档

美团线程池技术概要

参考多线程网站

Disruptor框架

美团技术团队

JVM相关

JVM 内存结构

双亲委派 / 沙盒安全

OOM demo

package com.qxy.practice.jvm;

/**
 * @author : 戚欣扬
 * @Description :
 */
public class OOMdemo1 {
    byte[] bytes = new byte[1*1024*1024];
    public static void main(String[] args) {
    //设置虚拟机参数：-Xlog:gc* -Xms10m -Xmx10m
        OOMdemo1 [] arr = new OOMdemo1[1000];
        System.out.println("start memory :"+Runtime.getRuntime().totalMemory()/(1024*1024));
        System.out.println("max memory :"+Runtime.getRuntime().maxMemory()/(1024*1024));
        int i = 0;
        while (true){
            arr[i++]=new OOMdemo1();
        }
    }
}

SOF demo

package com.qxy.practice.jvm;

/**
 * @author : 戚欣扬
 * @Description :
 */
public class SOFdemo {

    public void sof(){
        sof();
    }

    public static void main(String[] args) {
        SOFdemo soFdemo = new SOFdemo();
        System.out.println(soFdemo.getClass().getClassLoader());
        System.out.println(soFdemo.getClass().getClassLoader().getParent());
        System.out.println(soFdemo.getClass().getClassLoader().getParent().getParent());
            soFdemo.sof();

    }
}

GC流程

Java HotSpot JVM的GC流程：分代收集，Young代触发Minor GC标记清理，Old代触发Major/Full GC整理内存，优化空间分配，减少碎片。

GC roots

分类	具体类型	描述
虚拟机栈（Java Stack）	栈帧中的局部变量表引用的对象	包括方法的局部变量、参数等，只要在当前活跃的栈帧中，即被视为 GC Root。
方法区（Method Area）	类的静态字段（Static Fields）	类的静态变量引用的对象，生命周期与类加载器绑定。
	常量池（Runtime Constant Pool）中的引用对象	包括字符串常量池、类符号引用等，可能引用堆中的对象。
本地方法栈（Native Stack）	JNI（Java Native Interface）引用的对象	通过本地方法调用（如 C/C++）中引用的 Java 对象。
活跃线程（Active Threads）	正在运行的线程对象本身	线程对象及其栈中的局部变量均属于 GC Root。
	线程栈中的局部变量和参数	线程执行过程中创建的临时对象或参数。
同步监控对象（Monitor）	被 synchronized 锁持有的对象	同步块或方法中使用的监视器对象，可能引用其他对象。
系统类加载器（Class Loaders）	系统类加载器（Bootstrap、Extension、Application）加载的类及其静态字段	这些类及其静态变量通常不会被回收，引用的对象也是 GC Root。
JVM 内部对象	JVM 内部管理的对象（如 Class、Method、Field 等）	JVM 自身维护的元数据对象，例如类对象、方法句柄等。
	异常类（如 NullPointerException、OutOfMemoryError）	JVM 内部常驻的异常类对象。
	系统类加载器（如 ClassLoader 实例）	负责加载类的加载器对象本身。
反射与工具接口	通过反射 API（如 java.lang.reflect 包）创建的引用	反射机制可能持有的对象引用（如 Method、Field 实例）。
	JMXBean、JVMTI 回调、本地代码缓存	用于监控或调试的 JVM 内部对象。
其他特殊场景	临时性 GC Roots（如分代回收中的跨代引用）	根据垃圾收集器策略，某些临时对象可能被临时标记为 GC Root（如局部回收时的关联对象）。
	用户手动设置的引用（如 WeakReference、SoftReference）	通过显式引用保留的对象（需注意：弱引用不会阻止对象被回收，但某些引用可能被特殊处理）。

---

备注

1. 核心原则：所有 可达对象 必须能通过 GC Roots 的引用链追溯到，否则会被回收。
2. 实现差异：不同 JVM 实现（如 HotSpot、OpenJDK）或垃圾收集器（如 G1、CMS）可能对 GC Roots 的具体处理略有差异。
3. 动态性：某些 GC Roots（如活跃线程或本地方法引用）是动态变化的，随程序执行而改变。