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

文章目录

RunnableFuture接口实现类
线程池相关
JVM相关

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`）	通过显式引用保留的对象（需注意：弱引用不会阻止对象被回收，但某些引用可能被特殊处理）。