多线程学习总结（线程池的创建，及自定义线程池）

ゝ一纸荒年。 2023-02-26 13:23 244阅读 0赞

##### 1.线程池的优点：线程服用，控制最大并发数，管理线程 #####

##### 2.创建线程池的三大方法，Executors相当于工具类 #####

ExecutorService pool = Executors.newSingleThreadExecutor();//创建单一线程池
    ExecutorService pool1 = Executors.newFixedThreadPool(5);//创建5个线程池
    ExecutorService pool2 = Executors.newCachedThreadPool();//创建一个遇强则强的线程池

###### 单一线程只有一个线程去执行线程任务，第二个最多有五个线程去执行线程任务，第三个任务越多线程池越大。使用线程池之后，线程池来创建线程。execute方法创建线程 ######

public class Project01 { 
        public static void main(String[] args) { 
            //ExecutorService pool2 = Executors.newSingleThreadExecutor();//创建单一线程池
            //ExecutorService pool = Executors.newFixedThreadPool(5);//创建5个线程池
            ExecutorService pool1 = Executors.newCachedThreadPool();//创建一个遇强则强的线程池
            try { 
                for (int i = 0; i < 20; i++) { 
                    final int temp = i;
                    //创建10个线程
                    pool1.execute(()->{ 
                        System.out.println(Thread.currentThread().getName() + "->"+temp);
                    });
                }    
            }catch (Exception e){ 
                e.printStackTrace();
            }finally { 
                //使用完线程池，归还线程池,关闭
                pool1.shutdown();
            }
            
        }
    }

###### 工具类创建的线程池，如何创建的哪？ ######

##### 七大参数 #####

1.corePoolSize 核心线程池大小  
2.maximumPoolSize 最大核心线程池大小  
3.keepAliveTime 存活时间，（最大核心线程池大小-核心线程池大小）时间过后将会关闭这个大小的线程池  
4.unit 时间单位  
5.workQueue 阻塞队列  
6.threadFactory线程工厂  
7.handler 拒绝策略

public static ExecutorService newCachedThreadPool() { 
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) { 
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

###### 7大参数展示图 ######

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BfeGlhb3hpYW8_size_16_color_FFFFFF_t_70]

###### 用代码展示 ######

public class Project02 { 
        public static void main(String[] args) { 
        //自定义线程池
            ThreadPoolExecutor poolExecutor= new ThreadPoolExecutor(
                    2,//核心线程数
                    5,//最大核心线程数
                    3,
                    TimeUnit.SECONDS,//3S后关闭最大核心线程数
                    new LinkedBlockingDeque<>(3),//阻塞队列3个
                    Executors.defaultThreadFactory(),//默认线程工厂
                    new ThreadPoolExecutor.AbortPolicy()//拒绝策略
            );
            for (int i = 1; i <= 9; i++) { 
                poolExecutor.execute(()->{ 
                    System.out.println(Thread.currentThread().getName()+"执行了");
                });
            }
        }
    }

通过设置i的最大值，来判断结果  
1.i<=2 核心线程数,运行结果：  
pool-1-thread-1执行了  
pool-1-thread-2执行了  
2.i<=5 核心线程数和阻塞队列。所以还是2个核心线程数执行，运行结果：  
pool-1-thread-1执行了  
pool-1-thread-2执行了  
pool-1-thread-1执行了  
pool-1-thread-2执行了  
pool-1-thread-1执行了  
3.i<=8 最大核心线程数和阻塞队列，5个线程数执行，运行结果：  
pool-1-thread-1执行了  
pool-1-thread-4执行了  
pool-1-thread-3执行了  
pool-1-thread-2执行了  
pool-1-thread-3执行了  
pool-1-thread-4执行了  
pool-1-thread-1执行了  
pool-1-thread-5执行了  
4.当i = 9的时候，没有位置了，所以使用拒绝策略。抛出异常RejectedExecutionException。

#### 四种拒绝策略 ####

new ThreadPoolExecutor.AbortPolicy()//不会进行处理，直接抛出异常
    new ThreadPoolExecutor.CallerRunsPolicy()//不会处理，哪来的去哪里，返回给main线程去执行
    new ThreadPoolExecutor.DiscardPolicy()//队列满了，丢掉任务，不会抛出异常
    new ThreadPoolExecutor.DiscardOldestPolicy()//队列满了，会去获取首次执行的线程是否执行完，也不会抛出异常

#### 最大线程池如何定义–>CPU密集型，IO密集型 ####

CPU密集型：最大核心线程数,保持CPU效率最高  
IO密集型：判断程序中十分消耗IO线程。必须大于他。

Runtime.getRuntime().availableProcessors()

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BfeGlhb3hpYW8_size_16_color_FFFFFF_t_70]: /images/20230209/a55c3fb931134174845f34b653ec0abb.png