commons.box.util.SYSs Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of commons-box-app Show documentation
Common utils for BOX projects.
The newest version!
package commons.box.util;

import commons.box.app.AppError;
import commons.box.app.AppLog;

import javax.annotation.Nonnull;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;

/**
 * 系统工具
 * 创建作者：xingxiuyi 
 */
public final class SYSs {
    private static final AppLog LOG = Logs.get(SYSs.class);
    private static final ExecutorService ES = Executors.newCachedThreadPool();

    private SYSs() {
    }

    /**
     * 异步执行
     *
     * @param cmd
     * @return
     */
    public static Future async(final Runnable cmd) {
        return async(null, cmd, null);
    }

    /**
     * 异步执行，当失败时允许响应
     *
     * @param cmd
     * @param failed
     * @return
     */
    public static Future async(final Runnable cmd, final Consumer failed) {
        return async(null, cmd, failed);
    }


    /**
     * 异步提交命令 使用默认的线程池 失败时具有相应
     *
     * @param executorService
     * @param cmd
     * @param failed
     * @return
     */
    public static Future async(final ExecutorService executorService, final Runnable cmd, final Consumer failed) {
        if (cmd == null) return null;
        ExecutorService es = (executorService != null) ? executorService : ES;
        return es.submit(() -> {
            try {
                cmd.run();
            } catch (Throwable e) {
                LOG.warn(e.getMessage(), e);
                if (failed != null) {
                    try {
                        failed.accept(e);
                    } catch (Throwable ef) {
                        LOG.warn(ef.getMessage(), ef);
                    }
                }
            }
        });
    }

    /**
     * 序列化对象
     * 
     * 解析失败或者返回为空时，抛出异常
     * 

     * 注意，所声明的 Serializable 类必须存在（或上级存在）默认构造方法
     * 

     * 如果对象涉及复杂操作 通过 private Object readResolve() / private Object readObject() 进行配置，具体参考语言规范
     *
     * @param object
     * @return
     */
    @Nonnull
    public static byte[] objectSerial(@Nonnull Object object) throws AppError {
        byte[] result = null;
        try {
            ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
            ObjectOutputStream out = new ObjectOutputStream(byteOut);
            out.writeObject(object);
            out.flush();
            result = byteOut.toByteArray();
            out.close();
            byteOut.close();
        } catch (Throwable e) {
            throw AppError.error("序列化错误 - " + e.getMessage(), e);
        }
        if (result == null) throw AppError.error("生成了空数据");
        return result;
    }

    /**
     * 反序列化对象
     * 

     * 解析失败时，抛出异常
     * 

     * 注意，所声明的 Serializable 类必须存在（或上级存在）默认构造方法
     * 

     * 如果对象涉及复杂操作 通过 private Object readResolve() / private Object readObject() 进行配置，具体参考语言规范
     *
     * @param bytes
     * @return
     */
    @Nonnull
    public static Object objectDeserial(@Nonnull byte[] bytes) throws AppError {
        Object ro = null;
        try {
            ByteArrayInputStream byteIn = new ByteArrayInputStream(bytes);
            ObjectInputStream in = new ObjectInputStream(byteIn);
            ro = in.readObject();
            in.close();
            byteIn.close();
        } catch (Throwable e) {
            throw AppError.error("序列化错误 - " + e.getMessage(), e);
        }
        return ro;
    }

    /**
     * 测试对象是否能有效序列化和反序列化，返回空时序列化失败
     *
     * @param o
     * @return
     */
    public static Object checkSerial(@Nonnull Object o) {
        try {
            byte[] bs = objectSerial(o);
            if (bs.length < 1) throw AppError.error("序列化返回了空数组");
            return objectDeserial(bs);
        } catch (Throwable e) {
            LOG.error("序列化测试失败 - " + e.getMessage(), e);
        }
        return null;
    }

    /**
     * 休眠一段时间 毫秒单位
     *
     * @param ms
     */
    public static void ts(long ms) {
        if (ms < 0) return;
        try {
            Thread.sleep(ms);
        } catch (Throwable ignored) {
        }
    }

    /**
     * 在执行大批量循环时,当前线程可能会分配全部的可用时间片
     * 

     * 本方法使线程休眠0ms, 对真实运行效果没有影响,但是能够释放cpu资源给哪些急需cpu的其它线程
     */
    public static void ts0() {
        ts(0);
    }


    /**
     * 打印 System.out.println
     * 
     * 支持参数
     *
     * @param o
     * @param params
     */
    public static void println(Object o, Object... params) {
        System.out.println(Strs.format(o, params));
    }


    /**
     * 安全的处理逻辑 用于 executorService 彻底关闭
     *
     * @param executorService
     */
    public static void shutdown(ExecutorService executorService) {
        if (executorService == null) return;
        try {
            executorService.shutdown();
        } catch (Throwable ignored) {
        }
        try {
            for (int i = 0; i < 5; i++) {
                if (executorService.isShutdown() || executorService.isTerminated()) break;
                if (!executorService.awaitTermination(500, TimeUnit.MILLISECONDS)) executorService.shutdownNow();
            }
        } catch (Throwable e) {
            try {
                executorService.shutdownNow();
            } catch (Throwable ignored) {
            }
            LOG.error("无法停止服务处理队列");
        }
    }
}