Executors创建线程池

太过爱你忘了你带给我的痛 2023-07-08 09:05 20阅读 0赞

在jdk1.8版本加入WorkStealingPool线程后，通过Executors共可创建5种线程池

**newSingleThreadExecutor**是创建一个单任务线程池，串行执行所有任务。它只会用唯一的工作线程来执行任务，任务执行顺序按照先进先出（FIFO），如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。

**newCachedThreadPool**是创建一个缓存线程池，只有非核心线程，最大线程数很大，每新来一个任务，当没有空余线程的时候就会重新创建一个线程，这边有一个超时机制，当空闲的线程超过60s内没有用到的话，就会被回收，它可以一定程序减少频繁创建/销毁线程,减少系统开销，适用于执行时间短并且数量多的任务场景。

**newFixedThreadPool**是创建指定个数的线程。在程序执行时，可以同时允许这些线程并发执行。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务。

**newScheduledThreadPool**是创建一个定长线程池，支持定时及周期性任务执行。通过过schedule方法可以设置任务的周期执行延时执行，并行的任务数量是核心线程数，其余任务根据间隔时间下次执行。

**newWorkStealingPool**是创建一个窃取线程池，假设共有三个线程同时执行, A, B, C。当A,B线程池有未完成的任务,而C已经处理完毕,则C线程会从A或者B中窃取任务执行,这就叫工作窃取。假如A线程中的队列里面分配了3个任务，而B线程的队列中分配了1个任务，当B线程执行完任务后，它会主动的去A线程中窃取其他的任务进行执行。

/**
    *单任务线程池
    */
    ExecutorService pool = Executors.newSingleThreadExecutor();
                for (int i=0;i<10;i++){
                    final int task=i;
                    pool.execute(new Runnable() {
                        @Override
                        public void run() {
                            System.out.println("单任务线程池"+Thread.currentThread().getName()+"==="+task);
                            try {
                                Thread.sleep(5*1000);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
    
                        }
                    });
            }
    
    /**
    *定时周期线程池
    */
    ScheduledExecutorService service=   Executors.newScheduledThreadPool(5);
            for (int i=0;i<10;++i){
              final int task=i;
                service.schedule(new Runnable() {
                    @Override
                    public void run() {
                       // System.out.println("任务执行线程1"+Thread.currentThread().getName()+"==="+task);
                        //在5秒后执行这里5个线程在5秒后并发执行
                    }
                },5, TimeUnit.SECONDS);
            }
    /**
    *缓存线程池
    */
     ExecutorService threadPool= Executors.newCachedThreadPool();
            for (int i=0;i<10;i++){
                final int task=i;
                threadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("缓存线程池"+Thread.currentThread().getName()+"==="+task);
                    }
                });
            }
    /**
    *固定并发线程池
    */
     ExecutorService service = Executors.newFixedThreadPool(4);
            for (int i=0;i<10;++i){
                final  int task=i;
                service.execute(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("固定并发数线程池"+Thread.currentThread().getName()+"==="+task);
                    }
                });
            }
    /**
    *窃取线程池
    */
    ExecutorService executor = Executors.newWorkStealingPool(8);
            for (int i=0;i<5;i++){
                final int task=i;
                executor.execute(()->{
                    System.out.println("qq"+task);
                });
            }