动态分配线程数目-保证系统负载

package com.zte.sunquan.demo.executor;import com.google.common.util.concurrent.AtomicDouble;import com.google.common.util.concurrent.ThreadFactoryBuilder;import com.sun.management.OperatingSystemMXBean;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import java.lang.management.ManagementFactory;import java.lang.management.MemoryMXBean;import java.lang.management.MemoryUsage;import java.lang.management.ThreadMXBean;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.ThreadFactory;import java.util.concurrent.TimeUnit;/** * Created by sunquan on 2017/4/15. */public final class DynamicExecutorFactory {    private static final Logger logger = LoggerFactory.getLogger(DynamicExecutorFactory.class);    private static final int DEFAULT_THRESHOLD = 4;    private static AtomicDouble atomicDouble = new AtomicDouble(0L);    private static final boolean USELOAD = false;    private static final String GROUP_NAME = "dynamic-factory";    private DynamicExecutorFactory() {    }    static {        backgroundUpdate();    }    public static ExecutorService getExecutorService(int expiredNum) {        return getExecutorService(USELOAD, expiredNum);    }    public static ExecutorService getExecutorService(boolean useLoad, int expiredNum) {        int threads;        if (useLoad) {            threads = getThreadNum(expiredNum);        } else {            threads = expiredNum <= DEFAULT_THRESHOLD ? expiredNum : DEFAULT_THRESHOLD;        }        logger.info("create threads={} and expiredNum={}", threads, expiredNum);        return Executors.newFixedThreadPool(threads, GroupedThreadFactory.groupedThreadFactory(GROUP_NAME));    }    private static int getThreadNum(int expiredNum) {        if (expiredNum <= 2)            return expiredNum;        //注意第一次调用时，默认只给1个线程        int threadNum = (int) (expiredNum * atomicDouble.get());        return threadNum < 1 ? 1 : threadNum;    }    private static ThreadFactory getFactory(String groupName, String name, boolean daemon) {        ThreadFactoryBuilder threadFactoryBuilder = new ThreadFactoryBuilder();        threadFactoryBuilder.setNameFormat(name)                .setThreadFactory(GroupedThreadFactory.groupedThreadFactory(groupName));        threadFactoryBuilder.setDaemon(daemon);        return threadFactoryBuilder.build();    }    private static void backgroundUpdate() {        ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor(getFactory("dynamic-load-schedule", "s1", true));        executorService.scheduleWithFixedDelay(new CalSysLoadTask(), 10, 3, TimeUnit.SECONDS);    }    private static class CalSysLoadTask implements Runnable {        final OperatingSystemMXBean operatingSystemMXBean = ManagementFactory.getPlatformMXBean(OperatingSystemMXBean.class);        final MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();        final ThreadMXBean thread = ManagementFactory.getThreadMXBean();        @Override        public void run() {            double systemCpuLoad = 0;            double processCpuLoad = 0;            double usage = 0;            double threadRadio = 0;            double swapSpaceRadio = 0;            try {                systemCpuLoad = operatingSystemMXBean.getSystemCpuLoad();                processCpuLoad = operatingSystemMXBean.getProcessCpuLoad();                MemoryUsage memoryUsage = memoryMXBean.getHeapMemoryUsage();                usage = (double) memoryUsage.getUsed() / (double) memoryUsage.getCommitted();                double threadCount = (double) thread.getThreadCount();                double peakThreadCount = (double) thread.getPeakThreadCount();                threadRadio = 0L;                if (threadCount < peakThreadCount) {                    threadRadio = 1 - threadCount / peakThreadCount;                } else {                    threadRadio = 1 - peakThreadCount / threadCount;                }                long freeSwapSpaceSize = operatingSystemMXBean.getFreeSwapSpaceSize();                long totalSwapSpaceSize = operatingSystemMXBean.getTotalSwapSpaceSize();                swapSpaceRadio = (double) freeSwapSpaceSize / (double) totalSwapSpaceSize;                atomicDouble.set((1 - systemCpuLoad) * 0.2 + (1 - processCpuLoad) * 0.2                        + (1 - usage) * 0.1 + threadRadio * 0.3 + swapSpaceRadio * 0.2);            } catch (Exception e) {                logger.error("backgroundUpdate error =", e);            } finally {                StringBuilder stringBuilder = new StringBuilder();                stringBuilder.append("systemCpuLoad:").append(systemCpuLoad)                        .append("processCpuLoad:").append(processCpuLoad)                        .append("usage:").append(usage)                        .append("threadRadio:").append(threadRadio)                        .append("swapSpaceRadio:").append(swapSpaceRadio)                        .append("load:").append(atomicDouble.get());                logger.info(stringBuilder.toString());            }        }    }}

package com.zte.sunquan.demo.executor;import com.google.common.collect.Maps;import java.util.Map;import java.util.concurrent.ThreadFactory;/** * Created by sunquan on 2017/4/15. */public class GroupedThreadFactory implements ThreadFactory {    private final ThreadGroup group;    private static final Map<String, GroupedThreadFactory> FACTORIES = Maps.newConcurrentMap();    public GroupedThreadFactory(ThreadGroup group) {        this.group = group;    }    @Override    public Thread newThread(Runnable r) {        return new Thread(group, r);    }    public static GroupedThreadFactory groupedThreadFactory(String groupName) {        //oscp/a/b/c        GroupedThreadFactory groupedThreadFactory = FACTORIES.get(groupName);        if (groupedThreadFactory != null) {            return groupedThreadFactory;        }        int i = groupName.lastIndexOf("/");        if (i > 0) {            String parentGroupName = groupName.substring(0, i);            ThreadGroup parentGroup = groupedThreadFactory(parentGroupName).getGroup();            groupedThreadFactory = new GroupedThreadFactory(new ThreadGroup(parentGroup, groupName));        } else {            groupedThreadFactory = new GroupedThreadFactory(new ThreadGroup(groupName));        }        FACTORIES.putIfAbsent(groupName,groupedThreadFactory);        return groupedThreadFactory;    }    public ThreadGroup getGroup() {        return group;    }}

测试：

package com.zte.sunquan.demo.executor;import com.google.common.util.concurrent.ThreadFactoryBuilder;import org.junit.Test;import java.util.concurrent.CountDownLatch;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.ThreadFactory;/** * Created by sunquan on 2017/4/15. */public class ExecutorTest {    public ThreadFactory getFactory(String groupName, String name) {        ThreadFactoryBuilder threadFactoryBuilder = new ThreadFactoryBuilder();        threadFactoryBuilder.setNameFormat(name)                .setThreadFactory(GroupedThreadFactory.groupedThreadFactory(groupName));        return threadFactoryBuilder.build();    }    @Test    public void test() throws InterruptedException {        //对每一个事件都要定义其所在的事件组，事件名，并保持相关继承关系        CountDownLatch countDownLatch = new CountDownLatch(1);        ExecutorService executorService =                Executors.newFixedThreadPool(2, getFactory("sqGroup/a/b", "sqThread%d"));        executorService.execute(() -> {            System.out.println("hello,world");            System.out.println("ThreadParentGroup:" + Thread.currentThread().getThreadGroup().getParent().getName());            System.out.println("ThreadGroup:" + Thread.currentThread().getThreadGroup().getName());            System.out.println("ThreadName:" + Thread.currentThread().getName());            countDownLatch.countDown();        });        countDownLatch.await();        System.out.println(Thread.currentThread().getThreadGroup().getName());    }    @Test    public void dTest() throws InterruptedException {        ExecutorService executorService = DynamicExecutorFactory                .getExecutorService(true, 50);//只有1个线程        Thread.sleep(15000);        DynamicExecutorFactory.getExecutorService(true, 50);//压力计算得26个线程//        Thread.currentThread().join();    }}