单例模式应用

序言

单例模式我们了解过不少，前面也有篇文章简单的说了一下单例模式（链接：https://blog.csdn.net/zkkzpp258/article/details/111667568），由于文中：https://www.runoob.com/design-pattern/singleton-pattern.html网站讲的很详细了我就没有多赘述，还是多聊聊应用方面，毕竟学这些设计模式就是为了应用于实际。

经过我个人比较，我觉得比较好的单例模式设计方法主要是下面两种：

1. 通过静态内部类实现单例。静态内部类在初始化时里面的静态成员变量只会初始化一次。
2. 通过枚举实现单例。

静态内部类实现的单例

如下为静态内部类实现单例。

package com.hust.zhang.singleton;

public class HolderSingleton {
    public HolderSingleton() {
    }

    static class Holder {
        private static final HolderSingleton instance = new HolderSingleton();
    }

    public static final HolderSingleton getInstance() {
        return Holder.instance;
    }

}

枚举实现的单例

下面就看看用枚举实现的单例，枚举类型实际上会被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;

@Slf4j
public class ThreadPoolTest2 {
    static class ThreadProcess implements Runnable {
        private Deque deque;

        ThreadProcess(Deque deque) {
            this.deque = deque;
        }

        @Override
        public void run() {
            try {
                Object value = deque.peek();
                log.info("the task is running ... task value = {}", value);
            } finally {
                deque.poll();
            }
        }
    }

    public static void main(String[] args) {
        Deque deque = MyLinkedDeque.getInstance();
        ThreadPoolExecutor poolExecutor = ThreadPool.INSTANCE.getInstance();
        poolExecutor.submit(() -> {
            while (true) {
                if (!deque.isEmpty()) {
                    poolExecutor.submit(new ThreadProcess(deque));
                } else {
                    log.info("ConcurrentLinkedDeque is empty ...");
                }
                TimeUnit.SECONDS.sleep(1);
            }
        });

        //启一个线程每隔5秒往队列中加三任务
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    TimeUnit.SECONDS.sleep(5);
                    Arrays.asList("task1","task2",123).stream().forEach(value -> deque.add(value));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

输出效果如下，

总结

上面用这种方式去创建线程池不是说有多好，你也可以直接在类里创建ThreadPoolExecutor并带上线程池参数，只不过这样去写一个定制化的线程池自己调用起来方便点，自己的业务处理类也干净点。

有人可能在想，如果一个微服务里不同的业务都共同使用同一个线程池那么会不会互相影响，要不要不仅仅只创建一个线程池单例，其实创建多个线程池分开去管理，在计算机内部本质上也是相互抢占资源的，所以区别并不是那么大。

另外再补充一下，虽然之前的文章也提到过，阿里开发手册强制要求不要使用Executors创建线程池而要使用ThreadPoolExecutor的创建方式，这是为了让我们更加明确线程池的运行规则，规避资源耗尽的风险。

FixedThreadPool和SingleThreadPool：允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
CachedThreadPool和ScheduledThreadPool：允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。