架构师日记-从代码到设计的性能优化指南

/** * 反射工具类 * * @author liuhuiqing * @date 2023年5月7日 */public abstract class BeanUtils {    private static final Logger LOGGER = LoggerFactory.getLogger(BeanUtils.class);    private static final Field[] NO_FIELDS = {};    private static final Map<Class<?>, Field[]> DECLARED_FIELDS_CACHE = new ConcurrentReferenceHashMap<Class<?>, Field[]>(256);    private static final Map<Class<?>, Field[]> FIELDS_CACHE = new ConcurrentReferenceHashMap<Class<?>, Field[]>(256);
    /**     * 获取当前类及其父类的属性数组     *     * @param clazz     * @return     */    public static Field[] getFields(Class<?> clazz) {        if (clazz == null) {            throw new IllegalArgumentException("Class must not be null");        }        Field[] result = FIELDS_CACHE.get(clazz);        if (result == null) {            Field[] fields = NO_FIELDS;            Class<?> searchType = clazz;            while (Object.class != searchType && searchType != null) {                Field[] tempFields = getDeclaredFields(searchType);                fields = mergeArray(fields, tempFields);                searchType = searchType.getSuperclass();            }            result = fields;            FIELDS_CACHE.put(clazz, (result.length == 0 ? NO_FIELDS : result));        }        return result;    }
    /**     * 获取当前类属性数组(不包含父类的属性)     *     * @param clazz     * @return     */    public static Field[] getDeclaredFields(Class<?> clazz) {        if (clazz == null) {            throw new IllegalArgumentException("Class must not be null");        }        Field[] result = DECLARED_FIELDS_CACHE.get(clazz);        if (result == null) {            result = clazz.getDeclaredFields();            DECLARED_FIELDS_CACHE.put(clazz, (result.length == 0 ? NO_FIELDS : result));        }        return result;    }
    /**     * 数组合并     *     * @param array1     * @param array2     * @param <T>     * @return     */    public static <T> T[] mergeArray(final T[] array1, final T... array2) {        if (array1 == null || array1.length < 1) {            return array2;        }        if (array2 == null || array2.length < 1) {            return array1;        }        Class<?> compType = array1.getClass().getComponentType();        int newArrLength = array1.length + array2.length;        T[] newArr = (T[]) Array.newInstance(compType, newArrLength);        int firstArrayLen = array1.length;        System.arraycopy(array1, 0, newArr, 0, firstArrayLen);        try {            System.arraycopy(array2, 0, newArr, firstArrayLen, array2.length);        } catch (ArrayStoreException ase) {            final Class<?> type2 = array2.getClass().getComponentType();            if (!compType.isAssignableFrom(type2)) {                throw new IllegalArgumentException("Cannot store " + type2.getName() + " in an array of "                        + compType.getName(), ase);            }            throw ase;        }        return newArr;    }}

    /**
     * 反面教材示例     * @param param1     * @param param2     * @return     */    public ServiceResponse<String> badCase4Throw(String param1,String param2){        try {            Assert.notNull(param1, "param1 is null!");            Assert.notNull(param1, "param2 is null!");            // do something
        }catch (Throwable e){            return new ServiceResponse(ResponseCodeEnum.PARAM_ERROR);        }        return new ServiceResponse<>();    }

/**     * 正面教材示例     *     * @param param1     * @param param2     * @return     */    public ServiceResponse<String> normCase4Throw(String param1, String param2) {        if (StringUtils.isEmpty(param1)) {            return new ServiceResponse(ResponseCodeEnum.PARAM_ERROR);        }        if (StringUtils.isEmpty(param2)) {            return new ServiceResponse(ResponseCodeEnum.PARAM_ERROR);        }        try {            // do something
        } catch (Throwable e) {            return new ServiceResponse(ResponseCodeEnum.SYSTEM_ERROR, e.getMessage());        }        return new ServiceResponse<>();    }

LOGGER.info("result:" + JsonUtil.write2JsonStr(contextAdContains) + ", logid = " + DigitThreadLocal.getLogId());

public class Singleton {     private int number;    //一定要加上volatile关键字    private volatile static Singleton INSTANCE;
    //私有构造器    private Singleton(){        this.number = 10;    }
    public static Singleton getInstance() {        if (INSTANCE == null) {            synchronized (Singleton.class) {                if (INSTANCE == null) {                    //注意：在栈引用与堆对象进行绑定和对象初始化的过程的顺序就有可能出现指令重排，                    //导致其它线程拿到了未初始化成员变量的对象引用,比如取到的number=0                    INSTANCE = new Singleton();                }            }        }        return INSTANCE;    }}

/** * Least recently used 内存缓存过期策略:最近最少使用 * Title: 带容量的<b>线程不安全的</b>最近访问排序的Hashmap * Description: 最后访问的元素在最后面。<br> * 如果要线程安全，请使用<pre>Collections.synchronizedMap(new LRUHashMap(123));</pre> <br> * * @author: liuhuiqing * @date: 20123/4/27 */public class LRUHashMap<K, V> extends LinkedHashMap<K, V> {
    /**     * The Size.     */    private final int maxSize;
    /**     * 初始化一个最大值, 按访问顺序排序     *     * @param maxSize the max size     */    public LRUHashMap(int maxSize) {        //0.75是默认值，true表示按访问顺序排序        super(maxSize, 0.75f, true);        this.maxSize = maxSize;    }
    /**     * 初始化一个最大值, 按指定顺序排序     *     * @param maxSize     最大值     * @param accessOrder true表示按访问顺序排序，false为插入顺序     */    public LRUHashMap(int maxSize, boolean accessOrder) {        //0.75是默认值，true表示按访问顺序排序，false为插入顺序        super(maxSize, 0.75f, accessOrder);        this.maxSize = maxSize;    }
    @Override    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {        return super.size() > maxSize;    }
}

@GetMapping("/async/callable")public WebAsyncTask<String> asyncCallable() {    Callable<String> callable = () -> {        // 执行异步操作        return "异步任务已完成";    };    return new WebAsyncTask<>(10000, callable);}

@GetMapping("/async/deferredresult")public DeferredResult<String> asyncDeferredResult() {    DeferredResult<String> deferredResult = new DeferredResult<>(10000L);    // 异步处理完成后设置结果    deferredResult.setResult("DeferredResult异步任务已完成");    return deferredResult;}

Thread thread = Thread.ofVirtual()     .name("Virtual Threads")     .unstarted(runnable);

ThreadFactory factory = Thread.ofVirtual().factory();