2024年最新单例模式应用_jodd(6)，2024年最新BTAJ面试有关散列（哈希）表的面试题详解

2401_84830208

于 2024-05-15 13:22:06 发布

阅读量406

点赞数 4

文章标签： go 学习面试

本文链接：https://blog.csdn.net/2401_84830208/article/details/138905108

版权

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

}


## 枚举实现的单例


下面就看看用枚举实现的单例，枚举类型实际上会被Java编译器转换为一个对应的类，这个类继承了Java API中的java.lang.Enum类

public enum EnumSingleton {
INSTANCE;

EnumSingleton() {
    System.out.println("instance will be initialized immediately");
}

public static EnumSingleton getInstance() {
    return INSTANCE;
}

}


下面通过枚举实现的单例创建一个线程池，

package com.hust.zhang.threadpool;

import jodd.util.concurrent.ThreadFactoryBuilder;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.*;

@Slf4j
public enum ThreadPool {
INSTANCE;

private static final ThreadPoolExecutor THREAD_POOL_EXECUTOR;
//核心线程数
private static final int corePoolSize = 10;
//最大线程数
private static final int maxPoolSize = 30;
//工作队列大小
private static final int workQueueCapacity = 20;
//空闲线程存活时间
private static final long keepAliveTime = 30000L;


static {
    THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(corePoolSize,
            maxPoolSize,
            keepAliveTime,
            TimeUnit.MICROSECONDS,
            new LinkedBlockingQueue<>(workQueueCapacity),
            //使用链式方法创建ThreadFactory
            new ThreadFactoryBuilder().setNameFormat("my_definition_pool_").get(),
            CallerRunsPolicy拒绝策略：在任务被拒绝添加到队列中后，会用调用execute函数的上层线程去执行被拒绝的任务。
            new ThreadPoolExecutor.CallerRunsPolicy()) {
        /**
         * 处理线程池异常信息
         *
         * @param runnable
         * @param throwable
         */
        @Override
        protected void afterExecute(Runnable runnable, Throwable throwable) {
            super.afterExecute(runnable, throwable);
            if (throwable == null && runnable instanceof Future<?>) {
                try {
                    ((Future<?>) runnable).get();
                } catch (CancellationException ce) {
                    log.error("thread pool cancellation exception");
                } catch (ExecutionException ee) {
                    log.error("thread pool execution exception");
                } catch (InterruptedException ie) {
                    log.error("thread pool interrupted exception");
                    Thread.currentThread().interrupt();
                }
                if (throwable != null) {
                    log.error("thread pool exception");
                }
            }
        }
    };
    //允许核心线程回收
    THREAD_POOL_EXECUTOR.allowCoreThreadTimeOut(true);
}

public ThreadPoolExecutor getInstance() {
    return THREAD_POOL_EXECUTOR;
}

}


测试类如下，

package com.hust.zhang;

import com.alibaba.fastjson.JSON;
import com.hust.zhang.threadpool.ThreadPool;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.MDC;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadPoolExecutor;

@Slf4j
public class ThreadPoolTest {
static class ThreadProcess implements Runnable {
private int threadId;
private CountDownLatch countDownLatch;

    ThreadProcess(int threadId, CountDownLatch countDownLatch) {
        this.threadId = threadId;
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        try {
            MDC.put("threadId", String.valueOf(threadId));
        } finally {
            countDownLatch.countDown();
        }
    }
}

public static void main(String[] args) {
    //通过ThreadPool枚举获取实例中的带有参数的线程池
    ThreadPoolExecutor threadPool = ThreadPool.INSTANCE.getInstance();
    int threadNum = 5;
    CountDownLatch countDownLatch = new CountDownLatch(threadNum);
    for (int i = 0; i < threadNum; i++) {
        int threadId = i;
        log.info("threadPool parameter：= {}", JSON.toJSONString(threadPool));
        threadPool.submit(new ThreadProcess(threadId, countDownLatch));
    }
    try {
        countDownLatch.await();
    } catch (InterruptedException e) {
        log.info("throw InterruptedException");
    }
    System.out.println("mission accomplished!");
}

}


其中MDC可以用来记录线程的日志，方便在日志里通过grep命令追踪处理日志的线程。MDC通过MDCAdapter来实现，适配器有多种（BasicMDCAdapter、Log4jMDCAdapter、LogbackMDCAdapter、NOPMDCAdapter），主要是通过维护一个Map存与线程绑定的变量（ThreadLocal）。



上面是有限个任务放入到线程池中去，如果是无限个线程应该怎么做呢？下面针对可能会有无限个任务则放到队列中去，起一个线程循环判断队列是否为空，不为空则把任务放到线程池中。

package com.hust.zhang;

import com.hust.zhang.threadpool.ThreadPool;
import lombok.extern.slf4j.Slf4j;

import java.util.Arrays;
import java.util.Deque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;