常用的后端工具集

最新推荐文章于 2024-08-01 10:00:00 发布

灬点点

最新推荐文章于 2024-08-01 10:00:00 发布

阅读量715

点赞数 1

分类专栏： JAVA开发基础积累文章标签：常用的后端工具集网页游戏队列 java 后端

本文链接：https://blog.csdn.net/qq_32447301/article/details/106785047

版权

JAVA开发同时被 2 个专栏收录

285 篇文章 13 订阅

订阅专栏

基础积累

32 篇文章 3 订阅

订阅专栏

一、LinkedBlockingQueue的增强版

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.LinkedBlockingQueue;


/**
 * LinkedBlockingQueue的增强版（队伍内未消费的元素保证是不重复的）
 */
public class BlockingUniqueQueue<E> extends LinkedBlockingQueue<E> {

    private static final long serialVersionUID = 8351632564634804122L;

    private Set<E> datas = new HashSet<>();

    @Override
    public boolean contains(Object o) {
        return datas.contains(o);
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return datas.containsAll(c);
    }

    @Override
    public E take() {
        //该方法千万不要用 synchronized 修饰，不然一旦take()方法被阻塞了，另外一条线程就永远不能add了
        E head = null;
        try{
            head = super.take();
        }catch(Exception e){

        }
        datas.remove(head);
        return head;

    }

    @Override
    public synchronized boolean add(E e) {
        if (contains(e)) {
            return false;
        }
        datas.add(e);
        return super.add(e);
    }

    @Override
    public synchronized boolean addAll(Collection<? extends E> c) {
        boolean modified = false;
        for (E e : c) {
            if (add(e)) {
                modified = true;
            }
        }
        return modified;
    }

    @Override
    public synchronized boolean remove(Object o) {
        datas.remove(o);
        return super.remove(o);
    }

    @Override
    public synchronized boolean removeAll(Collection<?> c) {
        for (Object e:c) {
            datas.remove(e);
        }
        return super.removeAll(c);
    }

    @Override
    public Iterator<E> iterator() {
        return new Itr(super.iterator());
    }

    private class Itr implements Iterator<E> {

        private Iterator<E> it;

        private E curr;

        Itr(Iterator<E> it) {
            this.it = it;
        }

        @Override
        public boolean hasNext() {
            return this.it.hasNext();
        }

        @Override
        public E next() {
            this.curr = this.it.next();
            return this.curr;
        }

        @Override
        public void remove() {
            synchronized(BlockingUniqueQueue.this) {
                this.it.remove();
                BlockingUniqueQueue.this.datas.remove(this.curr);
            }
        }
    }

}

二、Jvm工具类

import java.io.OutputStream;
import java.lang.management.*;
import java.nio.charset.StandardCharsets;

/**
 * JvmUtils
 */
public class JvmUtils {

    /**
     * The java stack
     *
     * @param stream {@link OutputStream}
     * @throws Exception exception
     */
    public static void jStack(OutputStream stream) throws Exception {
        ThreadMXBean threadMxBean = ManagementFactory.getThreadMXBean();
        for (ThreadInfo threadInfo : threadMxBean.dumpAllThreads(true, true)) {
            stream.write(getThreadDumpString(threadInfo).getBytes(StandardCharsets.UTF_8));
        }
    }

    private static String getThreadDumpString(ThreadInfo threadInfo) {
        StringBuilder sb = new StringBuilder("\"" + threadInfo.getThreadName() + "\""
                + " Id=" + threadInfo.getThreadId() + " " + threadInfo.getThreadState());
        if (threadInfo.getLockName() != null) {
            sb.append(" on ").append(threadInfo.getLockName());
        }
        if (threadInfo.getLockOwnerName() != null) {
            sb.append(" owned by \"").append(threadInfo.getLockOwnerName())
                    .append("\" Id=").append(threadInfo.getLockOwnerId());
        }
        if (threadInfo.isSuspended()) {
            sb.append(" (suspended)");
        }
        if (threadInfo.isInNative()) {
            sb.append(" (in native)");
        }
        sb.append('\n');
        int i = 0;

        StackTraceElement[] stackTrace = threadInfo.getStackTrace();
        MonitorInfo[] lockedMonitors = threadInfo.getLockedMonitors();
        for (; i < stackTrace.length && i < 32; i++) {
            StackTraceElement ste = stackTrace[i];
            sb.append("\tat ").append(ste.toString());
            sb.append('\n');
            if (i == 0 && threadInfo.getLockInfo() != null) {
                Thread.State ts = threadInfo.getThreadState();
                switch (ts) {
                    case BLOCKED:
                        sb.append("\t-  blocked on ").append(threadInfo.getLockInfo());
                        sb.append('\n');
                        break;
                    case WAITING:
                        sb.append("\t-  waiting on ").append(threadInfo.getLockInfo());
                        sb.append('\n');
                        break;
                    case TIMED_WAITING:
                        sb.append("\t-  waiting on ").append(threadInfo.getLockInfo());
                        sb.append('\n');
                        break;
                    default:
                }
            }

            for (MonitorInfo mi : lockedMonitors) {
                if (mi.getLockedStackDepth() == i) {
                    sb.append("\t-  locked ").append(mi);
                    sb.append('\n');
                }
            }
        }
        if (i < stackTrace.length) {
            sb.append("\t...");
            sb.append('\n');
        }

        LockInfo[] locks = threadInfo.getLockedSynchronizers();
        if (locks.length > 0) {
            sb.append("\n\tNumber of locked synchronizers = ").append(locks.length);
            sb.append('\n');
            for (LockInfo li : locks) {
                sb.append("\t- ").append(li);
                sb.append('\n');
            }
        }
        sb.append('\n');

        return sb.toString();
    }

}

三、基于LinkedHashMap实现的一个有限队列缓存有时间及大小的限制

/**
 * 基于LinkedHashMap实现的一个有限队列缓存 有时间及大小的限制
 * aliveTime参数为true时为模拟lru规则
 */
public class LimitedCacheMap<K, V> {

    private LinkedHashMap<K, Element<V>> data;

    /**
     * 缓存最大容量，添加新元素时，若当前长度超过容量，则会删除队首元素
     */
    private int capacity;

    /** 生存时长（毫秒数） */
    private long aliveTime;

    /**
     * 是否使用lru规则，为true时表示当元素被查找命中时被重放到队尾
     *  {@link LinkedHashMap#accessOrder}}
     */
    private boolean useLru;

    /** 读写锁 */
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
    private ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();

    public LimitedCacheMap(int capacity, long aliveTime) {
        this(capacity, aliveTime, Boolean.FALSE);
    }

    public LimitedCacheMap(int capacity, long aliveTime, boolean useLru) {
        this.capacity = capacity;
        this.aliveTime = aliveTime;
        this.useLru = useLru;
        this.data = new LinkedHashMap<K, Element<V>>(capacity, 1.0f, useLru) {
            private static final long serialVersionUID = 1L;

            @Override
            protected boolean removeEldestEntry(Map.Entry<K, Element<V>> eldest) {
                if (size() > capacity) {
                    return true;
                }
                long eleAliveTime = System.currentTimeMillis() - eldest.getValue().bornTime;
                return (eleAliveTime > aliveTime);
            }
        };
    }

    public V put(K key, V value) {
        V preValue = null;
        Element<V> newValue = new Element<V>(value);

        readLock.lock();
        try {
            if (data.containsKey(key)) {
                preValue = data.get(key).value;
            }
            data.put(key, newValue);
            return preValue;
        } finally {
            readLock.unlock();
        }
    }

    public V get(K key) {
        // 当使用lru，元素重放回队尾涉及到写操作，所以用写锁
        Lock lock = this.useLru ? this.writeLock : this.readLock;
        lock.lock();
        Element<V> target = null;
        try {
            target = this.data.get(key);
            if (target == null) {
                return null;
            }
        } finally {
            lock.unlock();
        }
        long eleAlive = System.currentTimeMillis() - target.bornTime;
        if (eleAlive < aliveTime) {
            return target.value;
        }
        remove(key);
        return null;
    }

    public int size() {
        this.readLock.lock();
        try {
            return this.data.size();
        } finally {
            this.readLock.unlock();
        }
    }

    public void remove(K key) {
        this.writeLock.lock();
        try {
            this.data.remove(key);
        } finally {
            this.writeLock.unlock();
        }
    }

    public void clear() {
        this.writeLock.lock();
        try {
            this.data.clear();
        } finally {
            this.writeLock.unlock();
        }
    }

    @Override
    public String toString() {
        return "LinkedCacheMap{data=" + data + ", capacity=" + capacity + ", aliveTime=" + aliveTime + ", useLru="
                + useLru + "}";
    }

    @SuppressWarnings("hiding")
    class Element<V> {
        V value;
        /** 元素添加时的时间戳 */
        long bornTime;

        Element(V v) {
            this.value = v;
            this.bornTime = System.currentTimeMillis();
        }

        @Override
        public String toString() {
            return "Element{" +
                    "value=" + value +
                    ", bornTime=" + bornTime +
                    '}';
        }
    }

}

四、基于Lru算法的HashMap

import java.util.LinkedHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


/**
 * LruHashMap is an extension of Java's HashMap, which has a bounded size();
 * When it reaches that size, each time a new element is added, the least recently used (LRU) entry is removed.
 * Java makes it very easy to implement LruHashMap - all its functionality is already available from LinkedHashMap,
 * and we just need to configure that properly.
 * Note that LruHashMap is thread safe
 */
public class LruHashMap<K, V> extends LinkedHashMap<K, V> {

    private static final long serialVersionUID = -5167631809472116969L;

    private static final float DEFAULT_LOAD_FACTOR = 0.75f;

    private static final int DEFAULT_MAX_CAPACITY = 1000;
    private final Lock lock = new ReentrantLock();
    private volatile int maxCapacity;

    public LruHashMap() {
        this(DEFAULT_MAX_CAPACITY);
    }

    public LruHashMap(int maxCapacity) {
        super(16, DEFAULT_LOAD_FACTOR, true);
        this.maxCapacity = maxCapacity;
    }

    @Override
    protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
        return size() > maxCapacity;
    }

    @Override
    public boolean containsKey(Object key) {
        try {
            lock.lock();
            return super.containsKey(key);
        } finally {
            lock.unlock();
        }
    }

    @Override
    public V get(Object key) {
        try {
            lock.lock();
            return super.get(key);
        } finally {
            lock.unlock();
        }
    }

    @Override
    public V put(K key, V value) {
        try {
            lock.lock();
            return super.put(key, value);
        } finally {
            lock.unlock();
        }
    }

    @Override
    public V remove(Object key) {
        try {
            lock.lock();
            return super.remove(key);
        } finally {
            lock.unlock();
        }
    }

    @Override
    public int size() {
        try {
            lock.lock();
            return super.size();
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void clear() {
        try {
            lock.lock();
            super.clear();
        } finally {
            lock.unlock();
        }
    }

    public int getMaxCapacity() {
        return maxCapacity;
    }

    public void setMaxCapacity(int maxCapacity) {
        this.maxCapacity = maxCapacity;
    }

}

package com.xxxx.faceadd.jetcache;

import com.google.common.collect.Lists;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantLock;

public class LRUCache<K, V> {

    private final int limit;
    private final Map<K, V> cache;
    private final Deque<K> deque;
    private final ReentrantLock reentrantLock = new ReentrantLock();
    private static final int DEFAULT_CAPACITY = 16;
    private static final float DEFAULT_LOAD_FACTOR = 0.75f;

    public LRUCache(int limit) {
        this.limit = limit;
        deque = new ArrayDeque<>(limit);
        cache = new ConcurrentHashMap<>(DEFAULT_CAPACITY, DEFAULT_LOAD_FACTOR);
    }
    public LRUCache(int limit, int capacity, float loadFactor) {
        this.limit = limit;
        deque = new ArrayDeque<>(limit);
        cache = new ConcurrentHashMap<>(capacity, loadFactor);
    }
    public void put(K key, V value) {
        V v = cache.get(key);
        reentrantLock.lock();
        try {
            if(v == null){
                cache.put(key, value);
                deque.removeFirstOccurrence(key);
                deque.addFirst(key);
            } else {
                deque.removeFirstOccurrence(key);
                deque.addFirst(key);
            }
            if(size() > limit){
                K keys = deque.removeLast();
                if(keys != null){
                    cache.remove(keys);
                }
            }
        }finally {
            reentrantLock.unlock();
        }
    }
    public V get(K key) {
        V v = cache.get(key);
        if(v != null){
            reentrantLock.lock();
            try {
                deque.removeFirstOccurrence(key);
                deque.addFirst(key);
            } finally {
                reentrantLock.unlock();
            }
        }
        return v;
    }

    public int size() {
        return cache.size();
    }

    
    @Override
    public String toString() {
        List<String> values = Lists.newArrayListWithExpectedSize(limit);
        reentrantLock.lock();
        try {
            for (K k : this.deque) {
                 V v = cache.get(k);
                 values.add(k.toString() + " -> " + v.toString());
            }
        } finally {
            reentrantLock.unlock();
        }
        return values.toString();
    }
}

五、网络相关工具类

import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.net.*;
import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Random;
import java.util.regex.Pattern;

/**
 * NetUtils
 */
@Slf4j
public class NetUtils {

    public static final String LOCALHOST = "127.0.0.1";
    public static final String ANY_HOST = "0.0.0.0";
    private static final int RND_PORT_START = 30000;
    private static final int RND_PORT_RANGE = 10000;

    private static final Random RANDOM = new Random(System.currentTimeMillis());
    private static final int MIN_PORT = 0;
    private static final int MAX_PORT = 65535;
    private static final Pattern ADDRESS_PATTERN = Pattern.compile("^\\d{1,3}(\\.\\d{1,3}){3}\\:\\d{1,5}$");
    private static final Pattern LOCAL_IP_PATTERN = Pattern.compile("127(\\.\\d{1,3}){3}$");
    private static final Pattern IP_PATTERN = Pattern.compile("\\d{1,3}(\\.\\d{1,3}){3,5}$");
    private static final Map<String, String> HOST_NAME_CACHE = new LinkedHashMap<>();
    private static volatile InetAddress LOCAL_ADDRESS = null;
    private static volatile String PROCESS_ID = null;

    public static int getAvailablePort() {
        try (ServerSocket ss = new ServerSocket()) {
            ss.bind(null);
            return ss.getLocalPort();
        } catch (IOException e) {
            return RND_PORT_START + RANDOM.nextInt(RND_PORT_RANGE);
        }
    }

    public static int getAvailablePort(int port) {
        if (port <= 0) {
            return getAvailablePort();
        }
        for (int i = port; i < MAX_PORT; i++) {
            try (ServerSocket ss = new ServerSocket(i)) {
                return i;
            } catch (IOException e) {
                // continue
            }
        }
        return port;
    }

    public static boolean isInvalidPort(int port) {
        return port <= MIN_PORT || port > MAX_PORT;
    }

    public static boolean isValidAddress(String address) {
        return ADDRESS_PATTERN.matcher(address).matches();
    }

    public static boolean isLocalHost(String host) {
        return host != null
                && (LOCAL_IP_PATTERN.matcher(host).matches()
                || "localhost".equalsIgnoreCase(host));
    }

    public static boolean isAnyHost(String host) {
        return "0.0.0.0".equals(host);
    }

    public static boolean isInvalidLocalHost(String host) {
        return host == null
                || host.length() == 0
                || "localhost".equalsIgnoreCase(host)
                || "0.0.0.0".equals(host)
                || (LOCAL_IP_PATTERN.matcher(host).matches());
    }

    public static boolean isValidLocalHost(String host) {
        return !isInvalidLocalHost(host);
    }

    public static InetSocketAddress getLocalSocketAddress(String host, int port) {
        return isInvalidLocalHost(host) ?
                new InetSocketAddress(port) : new InetSocketAddress(host, port);
    }

    private static boolean isValidAddress(InetAddress address) {
        if (address == null || address.isLoopbackAddress()) {
            return false;
        }
        String name = address.getHostAddress();
        return (name != null
                && !ANY_HOST.equals(name)
                && !LOCALHOST.equals(name)
                && IP_PATTERN.matcher(name).matches());
    }

    public static String getLocalHost() {
        InetAddress address = getLocalAddress();
        return address == null ? LOCALHOST : address.getHostAddress();
    }

    /**
     * Find first valid IP from local network card
     *
     * @return first valid local IP
     */
    public static InetAddress getLocalAddress() {
        if (LOCAL_ADDRESS != null) {
            return LOCAL_ADDRESS;
        }
        InetAddress localAddress = getLocalAddress0();
        LOCAL_ADDRESS = localAddress;
        return localAddress;
    }

    private static InetAddress getLocalAddress0() {
        InetAddress localAddress = null;
        try {
            localAddress = InetAddress.getLocalHost();
            if (isValidAddress(localAddress)) {
                return localAddress;
            }
        } catch (Throwable e) {
            log.warn("Failed to retrieving ip address, " + e.getMessage(), e);
        }

        try {
            Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
            if (interfaces != null) {
                while (interfaces.hasMoreElements()) {
                    try {
                        NetworkInterface network = interfaces.nextElement();
                        Enumeration<InetAddress> addresses = network.getInetAddresses();
                        while (addresses.hasMoreElements()) {
                            try {
                                InetAddress address = addresses.nextElement();
                                if (isValidAddress(address)) {
                                    return address;
                                }
                            } catch (Throwable e) {
                                log.warn("Failed to retrieving ip address, " + e.getMessage(), e);
                            }
                        }
                    } catch (Throwable e) {
                        log.warn("Failed to retrieving ip address, " + e.getMessage(), e);
                    }
                }
            }
        } catch (Throwable e) {
            log.warn("Failed to retrieving ip address, " + e.getMessage(), e);
        }

        log.error("Could not get local host ip address, will use 127.0.0.1 instead.");
        return localAddress;
    }

    public static String getHostName(String address) {
        try {
            int i = address.indexOf(':');
            if (i > -1) {
                address = address.substring(0, i);
            }
            String hostname = HOST_NAME_CACHE.get(address);
            if (hostname != null && hostname.length() > 0) {
                return hostname;
            }
            InetAddress inetAddress = InetAddress.getByName(address);
            if (inetAddress != null) {
                hostname = inetAddress.getHostName();
                HOST_NAME_CACHE.put(address, hostname);
                return hostname;
            }
        } catch (Throwable e) {
            // ignore
        }

        return address;
    }

    public static String getIpByHost(String hostName) {
        try {
            return InetAddress.getByName(hostName).getHostAddress();
        } catch (UnknownHostException e) {
            return hostName;
        }
    }

    public static String toAddressString(InetSocketAddress address) {
        return address.getAddress().getHostAddress() + ":" + address.getPort();
    }

    public static InetSocketAddress toAddress(String address) {
        int i = address.indexOf(':');
        String host;
        int port;
        if (i > -1) {
            host = address.substring(0, i);
            port = Integer.parseInt(address.substring(i + 1));
        } else {
            host = address;
            port = 0;
        }

        return new InetSocketAddress(host, port);
    }

    public static String getProcessId() {
        if (PROCESS_ID != null) {
            return PROCESS_ID;
        }

        return PROCESS_ID = ManagementFactory.getRuntimeMXBean().getName().split("@")[0];
    }

}

六、防sql注入参数校验

import lombok.extern.slf4j.Slf4j;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 *  防sql注入参数校验
 * */
@Slf4j
public class ParamCheck {

    static String reg = "(?:')|(?:--)|(/\\*(?:.|[\\n\\r])*?\\*/)|"

            + "(\\b(select|update|and|or|delete|insert|trancate|char|into|substr|ascii|declare|exec|count|master|into|drop|execute)\\b)";


    /**
     * 表示忽略大小写
     */
    static Pattern sqlPattern = Pattern.compile(reg, Pattern.CASE_INSENSITIVE);



    /***************************************************************************
     * 参数校验
     * @param str ep: "or 1=1"
     */
    public static boolean isSqlValid(String str) {
        Matcher matcher = sqlPattern.matcher(str);
        if (matcher.find()) {
            //获取非法字符：or
            log.info("参数存在非法字符，请确认："+matcher.group());
            return false;
        }
        return true;
    }

}

七、对象池

import java.util.concurrent.LinkedBlockingQueue;


public class SimplyObjectPool<E extends MemoryObject> {

    private int capacity;

    private LinkedBlockingQueue<E> queue = new LinkedBlockingQueue<>();

    public SimplyObjectPool(int capacity) {
        this.capacity = capacity;
    }

    @SuppressWarnings("unchecked")
    public E borrowObject(Class<? extends MemoryObject> prototype) throws InstantiationException, IllegalAccessException {
        E object = queue.poll();
        if (object != null) {
            return object;
        }
        return (E) prototype.newInstance();
    }

    public void returnObject(E object) {
        if (this.queue.size() < capacity) {
            object.release();
            this.queue.offer(object);
        }
    }


}


public interface MemoryObject {

	/** 
	 * 释放相关引用
	 */
	void release();
}

八、流处理工具类

import com.google.common.base.Charsets;
import com.google.common.io.CharStreams;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.io.InputStreamReader;

/**
 * Stream Utils
 */
@Slf4j
public class StreamUtils {

    public static String loadScript(String name) {
        try {
            return CharStreams.toString(new InputStreamReader(
                    StreamUtils.class.getResourceAsStream(name), Charsets.UTF_8));
        } catch (IOException e) {
            log.error(e.getMessage(), e);
            return null;
        }
    }

}

九、list集合转String

import com.google.common.base.Joiner;
import java.util.List;

public class StringUtils {

    /**
     * list 转 String
     * @param list
     * @return
     */
    public static String listToJoiner(List<String> list) {
        return Joiner.on(",").join(list);
    }

    /**
     * list 转 String
     * @param list
     * @return
     */
    public static String listToString(List<String> list) {
        return String.join(",", list);
    }


}

十、利用ScheduledExecutorService实现高并发场景下System.currentTimeMillis()的性能问题的优化

import java.sql.Timestamp;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

/**
 * ClockUtils
 * <p>
 * 利用ScheduledExecutorService实现高并发场景下System.currentTimeMillis()的性能问题的优化.
 */
public class SystemClock {

    private static AtomicLong nowTime;
    private static volatile boolean started = false;

    /**
     * The get string current time
     *
     * @return string time
     */
    public static String currentTimeMillisStr() {
        return new Timestamp(currentTimeMillis()).toString();
    }

    /**
     * The get current time milliseconds
     *
     * @return long time
     */
    public static long currentTimeMillis() {
        if (!started) {
            synchronized (SystemClock.class) {
                if (!started) {
                    nowTime = new AtomicLong(System.currentTimeMillis());
                    ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(
                            1, r -> {
                        Thread thread = new Thread(r, "system-clock");
                        thread.setDaemon(true);
                        return thread;
                    });
                    executorService.scheduleAtFixedRate(() ->
                            nowTime.set(System.currentTimeMillis()), 1, 1, TimeUnit.MILLISECONDS);
                    Runtime.getRuntime().addShutdownHook(new Thread(executorService::shutdown));
                    started = true;
                }
            }
        }
        return nowTime.get();
    }
}

十一、获取系统内存与版本等工具类

import com.sun.management.OperatingSystemMXBean;
import lombok.Data;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;

import javax.management.MBeanServer;
import javax.management.ObjectName;
import java.io.File;
import java.io.Serializable;
import java.lang.management.GarbageCollectorMXBean;
import java.lang.management.ManagementFactory;
import java.math.BigDecimal;
import java.net.NetworkInterface;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;

/**
 * SystemUtils
 * <p>
 * 1.EnvironmentInfo
 * 2.MemoryInfo
 * 3.CpuLoadInfo
 * 4.DiskInfo
 * 5.GarbageCollectorInfo
 */
@Slf4j
public class SystemUtils {

    /**
     * The collect
     *
     * @return {@link MetricCollect}
     */
    public static MetricCollect collect() {
        MetricCollect metricCollect = new MetricCollect();
        metricCollect.setMemoryInfo(SystemUtils.getMemory());
        metricCollect.setCpuLoadInfo(SystemUtils.getCpuLoadInfo());
        metricCollect.setDiskInfo(SystemUtils.getDiskInfo());
        metricCollect.setGarbageCollectorInfos(SystemUtils.getGarbageCollectorInfo());
        return metricCollect;
    }

    @Data
    public static class MetricCollect implements Serializable {
        private static final long serialVersionUID = 3465584618686630943L;
        private SystemUtils.MemoryInfo memoryInfo;
        private SystemUtils.CpuLoadInfo cpuLoadInfo;
        private List<DiskInfo> diskInfo;
        private List<GarbageCollectorInfo> garbageCollectorInfos;
    }

    /**
     * The get environment info
     *
     * @return {@link EnvironmentInfo}
     */
    public static EnvironmentInfo getEnvironment() {
        EnvironmentInfo info = new EnvironmentInfo();
        info.setOsName(System.getProperty("os.name"));
        info.setOsVersion(System.getProperty("os.version"));
        info.setOsArch(System.getProperty("os.arch"));
        info.setJvmName(System.getProperty("java.vm.name"));
        info.setJvmVersion(System.getProperty("java.runtime.version"));
        info.setCpuCore(Runtime.getRuntime().availableProcessors());

        try {
            Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
            if (interfaces != null) {
                while (interfaces.hasMoreElements()) {
                    try {
                        NetworkInterface network = interfaces.nextElement();
                        if (network != null) {
                            info.setNetworkName(network.getName());
                            info.setNetworkDisplayName(network.getDisplayName());
                        }
                    } catch (Throwable e) {
                        log.warn("Failed to retrieving ip address, " + e.getMessage(), e);
                    }
                }
            }
        } catch (Throwable e) {
            log.warn("Failed to retrieving ip address, " + e.getMessage(), e);
        }

        return info;
    }


    /**
     * The get memory info
     *
     * @return {@link MemoryInfo}
     */
    public static MemoryInfo getMemory() {
        int mb = 1024 * 1024;
        Runtime runtime = Runtime.getRuntime();
        MemoryInfo memoryInfo = new MemoryInfo();

        // JVM
        double freeMemory = (double) runtime.freeMemory() / mb;
        double maxMemory = (double) runtime.maxMemory() / mb;
        double totalMemory = (double) runtime.totalMemory() / mb;
        double usedMemory = totalMemory - freeMemory;
        double percentUsed = (usedMemory / maxMemory) * 100.0;
        usedMemory = new BigDecimal(usedMemory).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        maxMemory = new BigDecimal(maxMemory).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        percentUsed = new BigDecimal(percentUsed).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        memoryInfo.setUsedMemory(usedMemory);
        memoryInfo.setMaxMemory(maxMemory);
        memoryInfo.setPercentUsed(percentUsed);

        // System
        OperatingSystemMXBean osBean = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
        double totalPhysicalMemory = (double) osBean.getTotalPhysicalMemorySize() / mb;
        double freePhysicalMemory = (double) osBean.getFreePhysicalMemorySize() / mb;
        double committedVirtualMemory = (double) osBean.getCommittedVirtualMemorySize() / mb;
        totalPhysicalMemory = new BigDecimal(totalPhysicalMemory).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        freePhysicalMemory = new BigDecimal(freePhysicalMemory).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        committedVirtualMemory = new BigDecimal(committedVirtualMemory).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        memoryInfo.setTotalPhysicalMemory(totalPhysicalMemory);
        memoryInfo.setFreePhysicalMemory(freePhysicalMemory);
        memoryInfo.setCommittedVirtualMemory(committedVirtualMemory);

        return memoryInfo;
    }

    /**
     * The get cpu load info
     *
     * @return {@link CpuLoadInfo}
     */
    public static CpuLoadInfo getCpuLoadInfo() {
        try {
            MBeanServer beanServer = ManagementFactory.getPlatformMBeanServer();
            ObjectName objectName = ObjectName.getInstance("java.lang:type=OperatingSystem");

            // read process cpu load
            Double processCpuLoad = getAttributeValue(beanServer, objectName, "ProcessCpuLoad");
            // read system cpu load
            Double systemCpuLoad = getAttributeValue(beanServer, objectName, "SystemCpuLoad");
            if (processCpuLoad != null || systemCpuLoad != null) {
                CpuLoadInfo cpuLoadInfo = new CpuLoadInfo();
                cpuLoadInfo.setProcessCpuLoad(processCpuLoad);
                cpuLoadInfo.setSystemCpuLoad(systemCpuLoad);
                return cpuLoadInfo;
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }

        return null;
    }

    /**
     * The get disk info
     *
     * @return {@link DiskInfo}
     */
    public static List<DiskInfo> getDiskInfo() {
        double mb = 1024 * 1024;

        List<DiskInfo> diskInfoList = new ArrayList<>();
        File[] disks = File.listRoots();
        for (File file : disks) {
            DiskInfo diskInfo = new DiskInfo();
            diskInfo.setPath(file.getPath());
            // 空闲空间
            diskInfo.setFreeSpace(new BigDecimal(
                    file.getFreeSpace() / mb).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
            // 可用空间
            diskInfo.setUsableSpace(new BigDecimal(
                    file.getUsableSpace() / mb).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
            // 总空间
            diskInfo.setTotalSpace(new BigDecimal(
                    file.getTotalSpace() / mb).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
            diskInfoList.add(diskInfo);
        }

        return diskInfoList;
    }

    /**
     * The get garbage collector info
     *
     * @return {@link GarbageCollectorInfo}
     */
    public static List<GarbageCollectorInfo> getGarbageCollectorInfo() {
        List<GarbageCollectorInfo> garbageCollectorInfoList = new ArrayList<>();
        List<GarbageCollectorMXBean> gcBeans = ManagementFactory.getGarbageCollectorMXBeans();
        for (GarbageCollectorMXBean gcBean : gcBeans) {
            GarbageCollectorInfo garbageCollectorInfo = new GarbageCollectorInfo();
            garbageCollectorInfo.setName(gcBean.getName());
            garbageCollectorInfo.setCollectionTime(gcBean.getCollectionTime());
            garbageCollectorInfo.setCollectionCount(gcBean.getCollectionCount());
            garbageCollectorInfoList.add(garbageCollectorInfo);
        }

        return garbageCollectorInfoList;
    }

    private static Double getAttributeValue(MBeanServer beanServer, ObjectName objectName, String attribute) throws Exception {
        Object cpuLoadObject = beanServer.getAttribute(objectName, attribute);
        if (cpuLoadObject == null) {
            return null;
        }

        double cpuLoadValue = (double) cpuLoadObject;
        if (cpuLoadValue < 0) {
            // usually takes a couple of seconds before we get real values
            return 0.00;
        }

        // returns a percentage value with 1 decimal point precision
        return new BigDecimal(cpuLoadValue * 100).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * EnvironmentInfo
     */
    @Data
    @ToString
    public static class EnvironmentInfo implements Serializable {

        private static final long serialVersionUID = -9055644935967288508L;

        private String osName;
        private String osVersion;
        private String osArch;
        private String jvmName;
        private String jvmVersion;
        private Integer cpuCore;
        private String networkName;
        private String networkDisplayName;
    }

    /**
     * MemoryInfo
     */
    @Data
    @ToString
    public static class MemoryInfo implements Serializable {

        private static final long serialVersionUID = -6078242692181489693L;

        // === JVM
        /**
         * Used memory(MB)
         */
        private double usedMemory;
        /**
         * Max memory(MB)
         */
        private double maxMemory;
        /**
         * Percent used(%)
         */
        private double percentUsed;

        // === System

        private double totalPhysicalMemory;
        private double freePhysicalMemory;
        private double committedVirtualMemory;

    }

    /**
     * CpuLoadInfo
     */
    @Data
    @ToString
    public static class CpuLoadInfo implements Serializable {

        private static final long serialVersionUID = -7983527685877649306L;

        /**
         * Process CPU load
         */
        private Double processCpuLoad;
        /**
         * System CPU load
         */
        private Double systemCpuLoad;

    }

    /**
     * DiskInfo
     */
    @Data
    @ToString
    public static class DiskInfo implements Serializable {

        private static final long serialVersionUID = 1486150261930978720L;

        private String path;
        private Double freeSpace;
        private Double usableSpace;
        private Double totalSpace;
    }

    /**
     * GarbageCollectorInfo
     */
    @Data
    @ToString
    public static class GarbageCollectorInfo implements Serializable {

        private static final long serialVersionUID = -6536126923166050353L;

        private String name;
        private Long collectionTime;
        private Long collectionCount;
    }

}

十二、三元结构体

/**
 * 三元结构体
 *
 * @param <F>
 * @param <S>
 * @param <T>
 */
public class Triple<F, S, T> {

	private F first;
	
	private S second;
	
	private T third;
	
	public Triple(F first, S second, T third) {
		this.first = first;
		this.second = second;
		this.third = third;
	}

	public F getFirst() {
		return first;
	}

	public void setFirst(F first) {
		this.first = first;
	}

	public S getSecond() {
		return second;
	}

	public void setSecond(S second) {
		this.second = second;
	}

	public T getThird() {
		return third;
	}

	public void setThird(T third) {
		this.third = third;
	}

	@Override
	public String toString() {
		return "Triple{" +
				"first=" + first +
				", second=" + second +
				", third=" + third +
				'}';
	}
}

十三、二元体结构

/**
 * 二元体结构
 */
public class Pair<F, S> {

    private final  F first;

    private final S second;

    public Pair(F first, S second) {
        this.first = first;
        this.second = second;
    }

    public F getFirst() {
        return first;
    }

    public S getSecond() {
        return second;
    }

    @Override
    public String toString() {
        return "Pair{" +
                "first=" + first +
                ", second=" + second +
                '}';
    }
}

十四、使用PriorityQueue作为任务工作队列实现Timer工具

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Date;
import java.util.PriorityQueue;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * jdk Timer工具的另一个实现
 * 区别：
 * 内部直接使用PriorityQueue作为任务工作队列
 * 运行过程中，若有一个task发生异常，整个Timer定时器不会关闭（jdk自带的timer会关闭）
 * 任务单元直接使用Runnable接口
 */
public class Timer {

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

    private PriorityQueue<TimerTask> queue;

    private final TimerThread thread;

    private static final AtomicInteger nextSerialNumber = new AtomicInteger(0);

    private static int serialNumber() {
        return nextSerialNumber.getAndIncrement();
    }

    public Timer() {
        this("Timer-" + serialNumber());
    }

    public Timer(boolean daemon) {
        this("Timer-" + serialNumber(), daemon);
    }

    public Timer(String threadName) {
        this.queue = new PriorityQueue<>();
        this.thread = new TimerThread(this.queue);
        this.thread.setName(threadName);
        this.thread.start();
    }

    public Timer(String threadName, boolean daemon) {
        this.queue = new PriorityQueue();
        this.thread = new TimerThread(this.queue);
        this.thread.setName(threadName);
        this.thread.setDaemon(daemon);
        this.thread.start();
    }

    public void schedule(Runnable task, long delay) {
        if (delay < 0L) {
            throw new IllegalArgumentException("Negative delay.");
        } else {
            this.schedule(task, System.currentTimeMillis() + delay, 0L);
        }
    }

    public void schedule(Runnable task, Date start) {
        this.schedule(task, start.getTime(), 0L);
    }

    public void scheduleAtFixedRate(Runnable task, long delay, long period) {
        if (delay < 0L) {
            throw new IllegalArgumentException("Negative delay.");
        } else if (period <= 0L) {
            throw new IllegalArgumentException("Non-positive period.");
        } else {
            this.schedule(task, System.currentTimeMillis() + delay, period);
        }
    }

    public void scheduleAtFixedRate(Runnable task, Date start, long period) {
        if (period <= 0L) {
            throw new IllegalArgumentException("Non-positive period.");
        } else {
            this.schedule(task, start.getTime(), period);
        }
    }

    private void schedule(Runnable task, long time, long period) {
        if (time < 0L) {
            throw new IllegalArgumentException("Illegal execution time.");
        } else {
            if (Math.abs(period) > 4611686018427387903L) {
                period >>= 1;
            }

            TimerTask timerTask = new TimerTask(task);
            synchronized(this.queue) {
                if (!this.thread.run) {
                    throw new IllegalStateException("Timer already cancelled.");
                } else {
                    synchronized(timerTask.lock) {
                        if (timerTask.state != 0) {
                            throw new IllegalStateException("Task already scheduled or cancelled");
                        }

                        timerTask.nextExecutionTime = time;
                        timerTask.period = period;
                        timerTask.state = TimerTask.SCHEDULED;
                    }

                    this.queue.add(timerTask);
                    if (this.queue.peek() == timerTask) {
                        this.queue.notify();
                    }
                }
            }
        }
    }

    public void cancel() {
        PriorityQueue<TimerTask> vars = this.queue;
        synchronized(this.queue) {
            this.thread.run = false;
            this.queue.clear();
            this.queue.notify();
        }
    }

}

class TimerThread extends Thread {

    boolean run = true;
    private PriorityQueue<TimerTask> queue;

    public TimerThread(PriorityQueue<TimerTask> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            mainLoop();
        } finally {
            // Someone killed this Thread, behave as if Timer cancelled
            synchronized(queue) {
                run = false;
                // Eliminate obsolete references
                queue.clear();
            }
        }
    }

    /**
     * The main timer loop.  (See class comment.)
     */
    private void mainLoop() {
        while (true) {
            try {
                TimerTask task;
                boolean taskFired;
                synchronized(queue) {
                    // Wait for queue to become non-empty
                    while (queue.isEmpty() && run) {
                        queue.wait();
                    }
                    if (queue.isEmpty()) {
                        break; // Queue is empty and will forever remain; die
                    }
                    // Queue nonempty; look at first evt and do the right thing
                    long currentTime, executionTime;
                    task = queue.peek();
                    synchronized(task.lock) {
                        if (task.state == TimerTask.CANCELLED) {
                            queue.poll();
                            continue;  // No action required, poll queue again
                        }
                        currentTime = System.currentTimeMillis();
                        executionTime = task.nextExecutionTime;
                        if (taskFired = (executionTime<=currentTime)) {
                            task = queue.poll();
                            // Non-repeating, remove
                            if (task.period == 0) {
                                task.state = TimerTask.EXECUTED;
                            } else { // Repeating task, reschedule
                                long nextExecTime = task.period < 0 ?
                                        currentTime - task.period
                                        : executionTime + task.period;
                                task.nextExecutionTime = nextExecTime;
                                queue.add(task);
                            }
                        }
                    }
                    // Task hasn't yet fired; wait
                    if (!taskFired) {
                        queue.wait(executionTime - currentTime);
                    }
                }
                // Task fired; run it, holding no locks
                if (taskFired) {
                    try {
                        task.run();
                    }catch (Exception e) {
                        Timer.logger.error("timer任务执行异常", e);
                    }
                }
            } catch(InterruptedException e) {
                // ignore it
            }
        }
    }

}

class TimerTask implements Runnable, Comparable<TimerTask> {

    private Runnable task;

    final Object lock = new Object();

    int state = VIRGIN;

    static final int VIRGIN = 0;

    static final int SCHEDULED   = 1;

    static final int EXECUTED    = 2;

    static final int CANCELLED   = 3;

    long nextExecutionTime;

    long period = 0;

    TimerTask(Runnable task) {
        this.task = task;
    }

    @Override
    public int compareTo(TimerTask timerTask) {
       if (timerTask.nextExecutionTime > this.nextExecutionTime) {
           return -1;
       }
        if (timerTask.nextExecutionTime < this.nextExecutionTime) {
            return 1;
        }
        return 0;
    }

    @Override
    public void run() {
        task.run();
    }
}

十五、线程设置名称

import com.google.common.util.concurrent.ThreadFactoryBuilder;
import lombok.extern.slf4j.Slf4j;
import org.apache.beam.repackaged.beam_sdks_java_core.org.apache.commons.lang3.concurrent.BasicThreadFactory;
import org.springframework.scheduling.concurrent.CustomizableThreadFactory;

import java.util.concurrent.*;

/**
 * 给线程取名称
 * @author nick
 */
@Slf4j
public class ThreadTools {


    /**
     * Spring 框架提供的 CustomizableThreadFactory
     * 本质 ：
     * final Thread thread = new Thread();
     * thread.setName(name);
     */
    private void test1(){
        ThreadFactory springThreadFactory = new CustomizableThreadFactory("springThread-pool-");
        ExecutorService exec = new ThreadPoolExecutor(1, 1,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(10),springThreadFactory);
        exec.submit(() -> log.info("-----"));
    }

    /**
     * Google guava 工具类 提供的 ThreadFactoryBuilder ,使用链式方法创建。
     * 本质 ：
     * final Thread thread = new Thread();
     * thread.setName(name);
     */
    private void test2(){
        ThreadFactory guavaThreadFactory = new ThreadFactoryBuilder().setNameFormat("retryClient-pool-").build();
        ExecutorService exec = new ThreadPoolExecutor(1, 1,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(10),guavaThreadFactory);
        exec.submit(() -> log.info("-----"));
    }


    /**
     * Apache commons-lang3 提供的 BasicThreadFactory
     * 本质 ：
     * final Thread thread = new Thread();
     * thread.setName(name);
      */
    private void test3(){
        ThreadFactory basicThreadFactory = new BasicThreadFactory.Builder()
                .namingPattern("basicThreadFactory-").build();
        ExecutorService exec = new ThreadPoolExecutor(1, 1,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(10),basicThreadFactory);
        exec.submit(() -> log.info("-----"));
    }
}

十六、Gzip

import ch.qos.logback.classic.pattern.TargetLengthBasedClassNameAbbreviator;
import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.StringTokenizer;
import java.util.concurrent.*;
import java.util.zip.GZIPOutputStream;

public class gzipOutputStreamUtils {

    public static ObjectMapper mapper = new ObjectMapper();

    static {
        // 转换为格式化的json
        mapper.enable(SerializationFeature.INDENT_OUTPUT);
        // 如果json中有新增的字段并且是实体类类中不存在的，不报错
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    }

    /**
     * 压缩请求日志
     * @param logger
     * @return
     */
    private byte[] buildRequestBody1(List<String> logger) {
        try {

            try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                 GZIPOutputStream gzipOutputStream = new GZIPOutputStream(byteArrayOutputStream)) {
                 gzipOutputStream.write(JSON.toJSONBytes(logger));
                 gzipOutputStream.finish();
                 gzipOutputStream.close();
                return byteArrayOutputStream.toByteArray();
            }
        }
        catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 压缩请求日志
     * @param logger
     * @return
     */
    private byte[] buildRequestBody2(List<String> logger) {
        try {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            try (GZIPOutputStream gzipOutputStream = new GZIPOutputStream(byteArrayOutputStream)) {
                gzipOutputStream.write(mapper.writeValueAsBytes(logger));
            }
            return byteArrayOutputStream.toByteArray();
        }
        catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 缩短包名
     * @param NameType
     * @param size
     * @return
     */
    private String getNameCurtali(String NameType, int size){
        TargetLengthBasedClassNameAbbreviator className = new TargetLengthBasedClassNameAbbreviator(size);
        return className.abbreviate(NameType);
    }



    private static final ExecutorService executorService = Executors.newSingleThreadExecutor();

    public FutureTask<String> getFutureTask() {
        return new FutureTask<>(() -> {
            System.out.println("hello");
            return "ok";
        });
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        gzipOutputStreamUtils futureTaskDemo = new gzipOutputStreamUtils();
        FutureTask<String> futureTask = futureTaskDemo.getFutureTask();
        executorService.execute(futureTask);

        Thread.sleep(100);
        if (futureTask.isDone()) {
            System.out.println(futureTask.get());
        }
        executorService.shutdown();
    }


    /**
     * ExtClassLoader类中获取路径的代码
     * @return
     */
    private static File[] getExtDirs() {
        //加载<JAVA_HOME>/lib/ext目录中的类库
        String string = System.getProperty("java.ext.dirs");
        File[] dirs;
        if (string != null) {
            StringTokenizer st = new StringTokenizer(string, File.pathSeparator);
            int count = st.countTokens();
            dirs = new File[count];
            for (int i = 0; i < count; i++) {
                dirs[i] = new File(st.nextToken());
            }
        } else {
            dirs = new File[0];
        }
        return dirs;
    }
    
}