Spring boot tomcat使用自定义线程池监控线程数量告警

Spring boot tocmat 使用自定义线程池

线程池 接近最大线程数量 警戒值告警

修改tomcat线程池中线程名字

配置文件上代码

server:
  port: 9898
  servlet:
    context-path: /test
  tomcat:
    connection-timeout: 5000
    max-connections: 5
    accept-count: 5
tomcat_thread_max_number_warn: 350
tomcat_thread_max_number: 500
tomcat_waiter_number: 500

自定义线程池TomcatMonitorConfig

package com.company.config;

import lombok.extern.slf4j.Slf4j;
import org.apache.coyote.AbstractProtocol;
import org.apache.coyote.ProtocolHandler;
import org.apache.tomcat.util.security.PrivilegedSetTccl;
import org.apache.tomcat.util.threads.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

@Slf4j
@Configuration
public class TomcatMonitorConfig {

    @Value("${tomcat_thread_max_number_warn}")
    private int maxThreadNumberWarn;

    @Value("${tomcat_thread_max_number}")
    private int maxThreadNumber;

    @Value("${tomcat_waiter_number}")
    private int waiterNumber;

    @Bean
    public WebServerFactoryCustomizer myWebServerFactoryCustomizer() {
        TaskThreadFactory tf = new TaskThreadFactory("tomcat-http" + "-exec-", true, 1);
        return new WebServerFactoryCustomizer<TomcatServletWebServerFactory>() {
            @Override
            public void customize(TomcatServletWebServerFactory factory) {
                Executor executor = (Executor)new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),
                        maxThreadNumber,
                        60,
                        TimeUnit.SECONDS,
                        new LinkedBlockingQueue<>(waiterNumber),
                        tf
                );
                factory.addConnectorCustomizers((connector) -> {
                    ProtocolHandler handler = connector.getProtocolHandler();
                    TaskQueue taskqueue = new TaskQueue();
                    if (handler instanceof AbstractProtocol) {
                        AbstractProtocol<?> protocol = (AbstractProtocol<?>) handler;
                        protocol.setExecutor(executor);
                    }
                });
            }
        };
    }

    class TaskThreadFactory implements ThreadFactory {
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;
        private final boolean daemon;
        private final int threadPriority;

        public TaskThreadFactory(String namePrefix, boolean daemon, int priority) {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
            this.namePrefix = namePrefix;
            this.daemon = daemon;
            this.threadPriority = priority;
        }

        @Override
        public Thread newThread(Runnable r) {
            int number = threadNumber.getAndIncrement();
            if(number>=maxThreadNumberWarn) {
                log.warn("Thread number is greater than "+maxThreadNumberWarn);
            }
            TaskThread t = new TaskThread(group, r, namePrefix + number);
            t.setDaemon(daemon);
            t.setPriority(threadPriority);

            // Set the context class loader of newly created threads to be the class
            // loader that loaded this factory. This avoids retaining references to
            // web application class loaders and similar.
            if (Constants.IS_SECURITY_ENABLED) {
                PrivilegedAction<Void> pa = new PrivilegedSetTccl(
                        t, getClass().getClassLoader());
                AccessController.doPrivileged(pa);
            } else {
                t.setContextClassLoader(getClass().getClassLoader());
            }

            return t;
        }
    }


}