线程池、多线程项目实战

        多线程一直是初学的小伙伴们的软肋，不过确实多线程会存在各种你在没有多线程的代码中遇不到的坑，或者说奇怪的现象。关于多线程的各种学习资料网上可以找到很多，但是我确实很少在网上找到具体实战的文章，所以我写一个我在项目中用过的代码，供大家参考。

        由于java自带的4个线程池，要不无限阻塞队列，要不无限线程创建，很容易导致OOM，所以我们还是要自己初始化自己的线程池，控制线程池的参数。

        线程池代码，大家可以看注释确定具体的配置参数，或者在网上查询线程池参数配置方法。

package xxx.xxx.xxx.xxx.config;

import lombok.Data;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Author xiarg
 * @CreateTime 2022/08/29  18:40
 */
@Component
public class ThreadPoolHandle {

    private static ThreadPoolExecutor threadPool;

    static {
        System.out.println("The Runner start to initialize ...");
        //创建线程池
        threadPool = new ThreadPoolExecutor(
                //线程池中的常驻核心线程数(假设银行窗口一般情况下开两个)
                2,
                //线程池能够容纳同时执行的最大线程数，此值必须>=1(特殊情况下比如周末办理业务人多，增设到5个窗口)
                5,
                //多余的空闲线程的存活时间 当前线程池数量超过 "corepoolsize"(认为有问题 应该是超过 maximumpoolsize吧)
                1L,
                // 当空闲时间达到keepalivetime值时，多余空闲线程会被销毁直到只剩下 corePoolSize个线程为止
                //unit keepAliveTime的单位
                TimeUnit.SECONDS,
                //任务队列，被提交但尚未被执行的任务（银行窗口的等待区的座位）
                new LinkedBlockingQueue<>(2),
                //线程工厂，用于生成线程池中的工作线程
                new MyThreadFactory("线程池名称"),
                //拒绝策略，当任务队列[LindedBlockingQueue]满了,
                // 并且工作线程[自己理解为办理业务的总认识，如以下代码中的10]大于等于线程池的最大线程数时如何拒绝多余工作线程
                new ThreadPoolExecutor.AbortPolicy()
        );
    }
    public static ThreadPoolExecutor getThreadPool(){
        return threadPool;
    }

}

        线程池中的线程个性化名称：

public class MyThreadFactory implements ThreadFactory{

        private final AtomicInteger poolNumber = new AtomicInteger(1);

        private final ThreadGroup threadGroup;

        private final AtomicInteger threadNumber = new AtomicInteger(1);

        public  final String namePrefix;

        MyThreadFactory (String name){
            SecurityManager s = System.getSecurityManager();
            threadGroup = (s != null) ? s.getThreadGroup() :
                    Thread.currentThread().getThreadGroup();
            if (null==name || "".equals(name.trim())){
                name = "pool";
            }
            namePrefix = name +"-"+
                    poolNumber.getAndIncrement() +
                    "-thread-";
        }

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(threadGroup, r,
                    namePrefix + threadNumber.getAndIncrement(),
                    0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }

         线程池具体调用方法，此处对于队列溢出，做了个处理，抛了个异常，并且捕获了异常，防止消息丢失。

    // 阻塞队列溢出，导致消息被放弃，所以需要在下面catch到，然后将消息保存在Redis缓存中，下次执行的时候把Redis中的消息拿出来执行。

    ThreadPoolExecutor threadPool = ThreadPoolHandle.getThreadPool()

    try{

        threadPool.execute(()->{
       
            // 处理消息具体逻辑

        });

    }catch (RejectedExecutionException e){
        //捕获到异常之后，将消息存储到Redis中，执行完毕之后，再次执行，再从Redis中获取
        System.out.println("捕获到异常===================->");
        System.out.println("把消息保存起来");
    }catch (Exception e){
        e.printStackTrace();
    }

        在此特别跟大家说下，如果要是搞不懂线程，可以自己写一段代码，测试感受下。切记，千万别直接用于生产。