private void test() {
    long s = System.currentTimeMillis();
    a(10);
    b(10);
    c(10);
    d(10);
    long e = System.currentTimeMillis();
    System.out.println(e - s);
}

public void a(int time) {
    try {
        Thread.sleep(time);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

public void b(int time) {
    try {
        Thread.sleep(time);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

public void c(int time) {
    try {
        Thread.sleep(time);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

public void d(int time) {
    try {
        Thread.sleep(time);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

private void test2() {
    long s = System.currentTimeMillis();
    List<CompletableFuture<?>> completableFutureList = new ArrayList <>();
    CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
        a(10);
    });
    completableFutureList.add(future1);
    CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
        b(10);
    });
    completableFutureList.add(future2);
    CompletableFuture<Void> future3 = CompletableFuture.runAsync(() -> {
        c(10);
    });
    completableFutureList.add(future3);
    CompletableFuture<Void> future4 = CompletableFuture.runAsync(() -> {
        d(10);
    });
    completableFutureList.add(future4);
    CompletableFuture<?>[] futures = completableFutureList.toArray(newCompletableFuture[0]);
    CompletableFuture<Void> futureAll = CompletableFuture.allOf(futures);
    futureAll.join();
    long e = System.currentTimeMillis();
    System.out.println(e - s);
}

public interface TransactionControlService {
    /**
     * 事務(wù)處理
     *
     * @param objectLogicFunction 業(yè)務(wù)邏輯
     * @param <T>                 result type
     * @return 處理結(jié)果
     * @throws Exception 業(yè)務(wù)異常信息
     */
    <T> T execute(ObjectLogicFunction<T> objectLogicFunction) throws Exception;
    /**
     * 事務(wù)處理
     *
     * @param voidLogicFunction 業(yè)務(wù)邏輯
     * @throws Exception 業(yè)務(wù)異常信息
     */
    void execute(VoidLogicFunction voidLogicFunction) throws Exception;
}

@Service
public class TransactionControlServiceImpl implements TransactionControlService {

    @Autowired
    private PlatformTransactionManager platformTransactionManager;

    @Autowired
    private TransactionDefinition transactionDefinition;

    /**
     * 事務(wù)處理
     *
     * @param businessLogic 業(yè)務(wù)邏輯
     * @param <T>           result type
     * @return 處理結(jié)果
     * @throws Exception 業(yè)務(wù)異常信息
     */
    @Override
    public <T> T execute(ObjectLogicFunction<T> businessLogic) throws Exception {
        TransactionStatus transactionStatus = platformTransactionManager.getTransaction(transactionDefinition);
        try {
            T resp = businessLogic.logic();
            platformTransactionManager.commit(transactionStatus);
            return resp;
        } catch (Exception e) {
            platformTransactionManager.rollback(transactionStatus);
            throw new Exception(e);
        }
    }

    /**
     * 事務(wù)處理
     *
     * @param businessLogic 業(yè)務(wù)邏輯
     */
    @Override
    public void execute(VoidLogicFunction businessLogic) throws Exception {
        TransactionStatus transactionStatus = platformTransactionManager.getTransaction(transactionDefinition);
        try {
            businessLogic.logic();
            platformTransactionManager.commit(transactionStatus);
        } catch (Exception e) {
            platformTransactionManager.rollback(transactionStatus);
            throw new Exception(e);
        }
    }
}

@FunctionalInterface
public interface ObjectLogicFunction<T> {

    /**
     * 業(yè)務(wù)邏輯處理
     *
     * @return 業(yè)務(wù)處理結(jié)果
     * @throws BusinessException e
     */
    T logic() throws BusinessException;
}

@FunctionalInterface
public interface VoidLogicFunction {

    /**
     * 業(yè)務(wù)邏輯處理
     *
     * @throws Exception e
     */
    void logic() throws Exception;
}

transactionControlService.execute(() -> {
    // 把需要事務(wù)控制的業(yè)務(wù)邏輯寫在這里即可
});

private static final ExecutorService executor = new ThreadPoolExecutor(
        2,
        4,
        1L,
        TimeUnit.MINUTES,
        new LinkedBlockingQueue<>(100),
        new ThreadFactoryBuilder().setNameFormat("common-pool-%d").build(),
        new ThreadPoolExecutor.CallerRunsPolicy());

public class ThreadPoolMonitor {

    private final static Logger log = LoggerFactory.getLogger(ThreadPoolMonitor.class);

    private static final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 0,
            TimeUnit.SECONDS, new LinkedBlockingQueue<>(100),
            new ThreadFactoryBuilder().setNameFormat("my_thread_pool_%d").build());

    public static void main(String[] args) {
        log.info("Pool Size: " + threadPool.getPoolSize());
        log.info("Active Thread Count: " + threadPool.getActiveCount());
        log.info("Task Queue Size: " + threadPool.getQueue().size());
        log.info("Completed Task Count: " + threadPool.getCompletedTaskCount());
    }
}

@Component
public class ThreadPoolMonitor {

    private static final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(4, 8, 0,
            TimeUnit.SECONDS, new LinkedBlockingQueue<>(100),
            new ThreadFactoryBuilder().setNameFormat("my_thread_pool_%d").build(), new ThreadPoolExecutor.DiscardOldestPolicy());

    /**
     * 活躍線程數(shù)
     */
    private AtomicLong activeThreadCount = new AtomicLong(0);

    /**
     * 隊列任務(wù)數(shù)
     */
    private AtomicLong taskQueueSize = new AtomicLong(0);

    /**
     * 完成任務(wù)數(shù)
     */
    private AtomicLong completedTaskCount = new AtomicLong(0);

    /**
     * 線程池中當(dāng)前線程的數(shù)量
     */
    private AtomicLong poolSize = new AtomicLong(0);

    @PostConstruct
    private void init() {

        /**
         * 通過micrometer API完成統(tǒng)計
         *
         * gauge最典型的使用場景就是統(tǒng)計：list、Map、線程池、連接池等集合類型的數(shù)據(jù)
         */
        Metrics.gauge("my_thread_pool_active_thread_count", activeThreadCount);
        Metrics.gauge("my_thread_pool_task_queue_size", taskQueueSize);
        Metrics.gauge("my_thread_pool_completed_task_count", completedTaskCount);
        Metrics.gauge("my_thread_pool_size", poolSize);

        // 模擬線程池的使用
        new Thread(this::runTask).start();
    }

    private void runTask() {
        // 每5秒監(jiān)控一次線程池的使用情況
        monitorThreadPoolState();
        // 模擬任務(wù)執(zhí)行
        IntStream.rangeClosed(0, 500).forEach(i -> {
            // 每500毫秒，執(zhí)行一個任務(wù)
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 每個處理一個任務(wù)耗時5秒
            threadPool.submit(() -> {
                try {
                    TimeUnit.MILLISECONDS.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        });
    }

    private void monitorThreadPoolState() {
        Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate(() -> {
            activeThreadCount.set(threadPool.getActiveCount());
            taskQueueSize.set(threadPool.getQueue().size());
            poolSize.set(threadPool.getPoolSize());
            completedTaskCount.set(threadPool.getCompletedTaskCount());
        }, 0, 5, TimeUnit.SECONDS);
    }
}

public class CacheLine {
    public static void main(String[] args) {
        int[][] arr = new int[10000][10000];
        long s = System.currentTimeMillis();
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = 0;
            }
        }
        long e = System.currentTimeMillis();
        System.out.println(e-s);
    }
}

public class CacheLine {
    public static void main(String[] args) {
        int[][] arr = new int[10000][10000];
        long s = System.currentTimeMillis();
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[j][i] = 0;
            }
        }
        long e = System.currentTimeMillis();
        System.out.println(e-s);
    }
}

public class CacheLinePadding {
    private static class Padding {
     // 一個long是8個字節(jié)，一共7個long
        // public volatile long p1, p2, p3, p4, p5, p6, p7;
    }

    private static class T extends Padding {
     // x變量8個字節(jié)，加上Padding中的變量，剛好64個字節(jié)，獨占一個緩存行。
        public volatile long x = 0L;
    }

    public static T[] arr = new T[2];

    static {
        arr[0] = new T();
        arr[1] = new T();
    }

    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(() -> {
            for (long i = 0; i < 10000000; i++) {
                arr[0].x = i;
            }
        });

        Thread t2 = new Thread(() -> {
            for (long i = 0; i < 10000000; i++) {
                arr[1].x = i;
            }
        });

        final long start = System.nanoTime();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println((System.nanoTime() - start)  / 100000);
    }
}

public class Main {

    public static void main(String[] args) {
        long s = System.currentTimeMillis();
        testInteger();
        long e = System.currentTimeMillis();
        System.out.println(e - s);
        testInt();
        long e2 = System.currentTimeMillis();
        System.out.println(e2 - e);
    }

    private static void testInt() {
        int sum = 1;
        for (int i = 1; i < 50000000; i++) {
            sum++;
        }
        System.out.println(sum);
    }

    private static void testInteger() {
        Integer sum = 1;
        for (int i = 1; i < 50000000; i++) {
            sum++;
        }
        System.out.println(sum);
    }
}

String str = new String("abc"); 
String str = "abc";

Boolean.valueOf("true");

public static Boolean valueOf(String s) {
    return parseBoolean(s) ? TRUE : FALSE;
}

public static final Boolean TRUE = new Boolean(true);

public static final Boolean FALSE = new Boolean(false);

public class StaticSingleton {
    private static class StaticHolder {
        public static final StaticSingleton INSTANCE = new StaticSingleton();
    }

    public static StaticSingleton getInstance() {
        return StaticHolder.INSTANCE;
    }
}

public enum EnumSingleton { INSTANCE; }

public Set<K> keySet() {
    Set<K> ks = keySet;
    if (ks == null) {
        ks = new KeySet();
        keySet = ks;
    }
    return ks;
}

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.11.1</version>
</dependency>

@Data
public class Cache {
    private byte[] size;
}

public class CachePoolObjectFactory extends BasePooledObjectFactory<Cache> {

    @Override
    public Cache create() {
        Cache cache = new Cache();
        cache.setSize(new byte[1024 * 1024 * 16]);
        return cache;
    }

    @Override
    public PooledObject<Cache> wrap(Cache cache) {
        return new DefaultPooledObject<>(cache);
    }
}

public enum CachePoolUtil {

    INSTANCE;

    private GenericObjectPool<Cache> objectPool;

    CachePoolUtil() {
        GenericObjectPoolConfig<Cache> poolConfig = new GenericObjectPoolConfig<>();
        // 對象池中最大對象數(shù)
        poolConfig.setMaxTotal(50);
        // 對象池中最小空閑對象數(shù)
        poolConfig.setMinIdle(20);
        // 對象池中最大空閑對象數(shù)
        poolConfig.setMaxIdle(20);
        // 獲取對象最大等待時間 默認 -1 一直等待
        poolConfig.setMaxWait(Duration.ofSeconds(3));
        // 創(chuàng)建對象工廠
        CachePoolObjectFactory objectFactory = new CachePoolObjectFactory();
        // 創(chuàng)建對象池
        objectPool = new GenericObjectPool<>(objectFactory, poolConfig);
    }

    /**
     * 從對象池中取出一個對象
     */
    public Cache borrowObject() throws Exception {
        return objectPool.borrowObject();
    }

    public void returnObject(Cache cache) {
        // 將對象歸還給對象池
        objectPool.returnObject(cache);
    }

    /**
     * 獲取活躍的對象數(shù)
     */
    public int getNumActive() {
        return objectPool.getNumActive();
    }

    /**
     * 獲取空閑的對象數(shù)
     */
    public int getNumIdle() {
        return objectPool.getNumIdle();
    }

}

public class Main {

    public static void main(String[] args) {
        CachePoolUtil cachePoolUtil = CachePoolUtil.INSTANCE;
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @SneakyThrows
                @Override
                public void run() {
                    while (true) {
                        Thread.sleep(100);
                        
                        // 使用對象池
                        Cache cache = cachePoolUtil.borrowObject();
                        m(cache);
                        cachePoolUtil.returnObject(cache);
                        
                        // 不使用對象池
                        //Cache cache = new Cache();
                        //cache.setSize(new byte[1024 * 1024 * 2]);
                        //m(cache);

                    }

                }
            }).start();
        }
    }
    
    // 無特殊作用
    public static void m(Cache cache) {
        if (cache.getSize().length < 10) {
            System.out.println(cache);
        }
    }
}

protected int next(int bits) {
    long oldseed, nextseed;
    AtomicLong seed = this.seed;
    do {
        oldseed = seed.get();
        nextseed = (oldseed * multiplier + addend) & mask;
    } while (!seed.compareAndSet(oldseed, nextseed));
    return (int)(nextseed >>> (48 - bits));
}

public static ThreadLocalRandom current() {
    if (U.getInt(Thread.currentThread(), PROBE) == 0)
        localInit();
    return instance;
}
static final void localInit() {
    int p = probeGenerator.addAndGet(PROBE_INCREMENT);
    int probe = (p == 0) ? 1 : p; // skip 0
    long seed = mix64(seeder.getAndAdd(SEEDER_INCREMENT));
    Thread t = Thread.currentThread();
    U.putLong(t, SEED, seed);
    U.putInt(t, PROBE, probe);
}
public int nextInt() {
    return mix32(nextSeed());
}
final long nextSeed() {
    Thread t; long r; // read and update per-thread seed
    U.putLong(t = Thread.currentThread(), SEED,
              r = U.getLong(t, SEED) + GAMMA);
    return r;
}

public E get(int index) {
    return elementAt(getArray(), index);
}
final Object[] getArray() {
    return array;
}
public boolean add(E e) {
    synchronized (lock) {
        Object[] es = getArray();
        int len = es.length;
        es = Arrays.copyOf(es, len + 1);
        es[len] = e;
        setArray(es);
        return true;
    }
}
final void setArray(Object[] a) {
    array = a;
}

public class ThreadSafeSet {
    public static void main(String[] args) throws InterruptedException {

        //Set<String> set = ConcurrentHashMap.newKeySet();

        //CopyOnWriteArraySet<String> set = new CopyOnWriteArraySet();

        readMoreWriteLess(set);

        System.out.println("==========華麗的分隔符==========");

        //set = ConcurrentHashMap.newKeySet();

        //set = new CopyOnWriteArraySet();

        writeMoreReadLess(set);
    }

    private static void writeMoreReadLess(Set<String> set) throws InterruptedException {
        //測20組
        for (int k = 1; k <= 20; k++) {
            CountDownLatch countDownLatch = new CountDownLatch(10);
            long s = System.currentTimeMillis();
            //創(chuàng)建9個線程，每個線程向set中寫1000條數(shù)據(jù)
            for (int i = 0; i < 9; i++) {
                new Thread(() -> {
                    for (int j = 0; j < 1000; j++) {
                        set.add(UUID.randomUUID().toString());
                    }
                    countDownLatch.countDown();
                }).start();
            }

            //創(chuàng)建1個線程，每個線程從set中讀取所有數(shù)據(jù)，每個線程一共讀取10次。
            for (int i = 0; i < 1; i++) {
                new Thread(() -> {
                    for (int j = 0; j < 10; j++) {
                        Iterator<String> iterator = set.iterator();
                        while (iterator.hasNext()) {
                            iterator.next();
                        }
                    }
                    countDownLatch.countDown();
                }).start();
            }
            //阻塞，直到10個線程都執(zhí)行結(jié)束
            countDownLatch.await();
            long e = System.currentTimeMillis();
            System.out.println("寫多讀少：第" + k + "次執(zhí)行耗時：" + (e - s) + "毫秒" + "，容器中元素個數(shù)為：" + set.size());
        }
    }

    private static void readMoreWriteLess(Set<String> set) throws InterruptedException {
        //測20組
        for (int k = 1; k <= 20; k++) {
            CountDownLatch countDownLatch = new CountDownLatch(10);
            long s = System.currentTimeMillis();
            //創(chuàng)建1個線程，每個線程向set中寫10條數(shù)據(jù)
            for (int i = 0; i < 1; i++) {
                new Thread(() -> {
                    for (int j = 0; j < 10; j++) {
                        set.add(UUID.randomUUID().toString());
                    }
                    countDownLatch.countDown();
                }).start();
            }

            //創(chuàng)建9個線程，每個線程從set中讀取所有數(shù)據(jù)，每個線程一共讀取100萬次。
            for (int i = 0; i < 9; i++) {
                new Thread(() -> {
                    for (int j = 0; j < 1000000; j++) {
                        Iterator<String> iterator = set.iterator();
                        while (iterator.hasNext()) {
                            iterator.next();
                        }
                    }
                    countDownLatch.countDown();
                }).start();
            }
            countDownLatch.await();
            long e = System.currentTimeMillis();
            System.out.println("讀多寫少：第" + k + "次執(zhí)行耗時：" + (e - s) + "毫秒" + "，容器中元素個數(shù)為：" + set.size());
        }
    }
}

public class COWSetTest {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArraySet<Integer> set = new CopyOnWriteArraySet();
        new Thread(() -> {
            try {
                set.add(1);
                System.out.println("第一個線程啟動，添加了一個元素，睡100毫秒");
                Thread.sleep(100);
                set.add(2);
                set.add(3);
                System.out.println("第一個線程添加了3個元素，執(zhí)行結(jié)束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        //保證讓第一個線程先執(zhí)行
        Thread.sleep(1);

        new Thread(() -> {
            try {
                System.out.println("第二個線程啟動了！睡200毫秒");
                //Thread.sleep(200);//如果在這邊睡眠，可以獲取到3個元素
                Iterator<Integer> iterator = set.iterator();//生成快照
                Thread.sleep(200);//如果在這邊睡眠，只能獲取到1個元素
                while (iterator.hasNext()) {
                    System.out.println("第二個線程開始遍歷，獲取到元素：" + iterator.next());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

    }
}

for(String userId : userIds){
    User user = userMapper.queryById(userId);
    if(user.getName().equals("xxx")){
        // ...
    }
    
}

Map<String, User> userMap = userMapper.queryByIds(userIds);
for(String userId : userIds){
    User user = userMap.get(userId);
    if(user.getName().equals("xxx")){
        // ...
    }
}

Map<String, User> userMap = userMapper.queryByIds(userIds);
for(String userId : userIds){
    User user = userMap.get(userId);
    Role role = roleMapper.queryById(user.getRoleId());
}

Map<String, User> userMap = userMapper.queryByIds(userIds);
Map<String, Role> roleMap = new HashMap<>();
for(String userId : userIds){
    User user = userMap.get(userId);
    Role role = roleMap.get(user.getRoleId());
    if(role == null){
        role = roleMapper.queryById(user.getRoleId());
        roleMap.put(user.getRoleId(), role);
    }
}

Integer sum = numbers.parallelStream().reduce(0, Integer::sum);

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i);
}
System.out.println("壓縮前：" + sb.toString().getBytes().length);
byte[] compressedBytes = ZipUtil.gzip(sb.toString(), CharsetUtil.UTF_8);
System.out.println("壓縮后：" + compressedBytes.length);
String str = ZipUtil.unGzip(compressedBytes, CharsetUtil.UTF_8);
System.out.println("壓縮還原：" + str.getBytes().length);

壓縮前：2890
壓縮后：1474
壓縮還原：2890

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i);
}
System.out.println("壓縮前：" + sb.toString().getBytes().length);
byte[] compressedBytes = ZipUtil.zlib(sb.toString(), CharsetUtil.UTF_8, 1);
System.out.println("壓縮后：" + compressedBytes.length);
String str = ZipUtil.unZlib(compressedBytes, CharsetUtil.UTF_8);
System.out.println("壓縮還原：" + str.getBytes().length);

壓縮前：2890
壓縮后：1518
壓縮還原：2890