多线程-（线程池）

Posted 2021-06-26 秃头小宝儿

线程池

• 1.线程池
• • （1）线程的缺点
  • （2）线程池的优点
  • （3）线程池的创建
  • • ①创建固定个数的线程池
    • ②创建带缓存线程池
    • ③创建可以执行定时任务的线程池
    • ④创建单线程执行定时任务的线程池
    • ⑤创建单个线程池
    • ⑥根据当前的硬件CPU生成对应个数的线程池，并且是异步处理。（JDK8+）
• 2.原始的线程池创建方式ThreadPoolExecutor()
• • （1）代码实现
  • （2）线程池的拒绝策略
  • （3）ThreadPoolExecutor执行流程：核心线程数、最大线程数、任务队列
  • （4）线程池执行的2种方式
  • （5)线程池终止的2种方式
  • （6）线程池的状态（线程的状态不等于线程池的状态）

1.线程池

定义：使用池化技术来管理线程和使用线程的方式。
线程池有两个重要的对象：

1.线程
2.工作队列（Integer最大值）

（1）线程的缺点

• 1.线程的创建它会开辟本地方法栈、虚拟机栈、程序计数器成线程私有的内存，同时销毁的时候需要销毁这三个区域，因此频繁的创建和销毁会消耗系统资源。
• 2.在任务量远远大于线程可以处理的任务量的时候，并不能友好拒绝任务。

（2）线程池的优点

• 1.可以避免频繁的创建和销毁线程带来的系统性能的开销。
• 2.可以更好的管理线程的个数和资源的个数。
• 3.拥有更多的功能，比如线程池可以进行定时任务的执行。
• 4.线程池可以更友好的拒绝不能处理的任务。

（3）线程池的创建

①创建固定个数的线程池

//创建一个固定个数的线程池
  ExecutorService executorService= Executors.newFixedThreadPool(10);
    //执行任务
     for (int i = 0; i <15 ; i++) {
        executorService.execute(new Runnable() {
             @Override
          public void run() {
             System.out.println("线程名："+Thread.currentThread().getName());//拿到当前线程的名称
                }
            });
        }

②创建带缓存线程池

使用场景：短期有大量任务的时候可以使用newCachedThreadPool()

//创建带缓存的线程池
   ExecutorService executorService= Executors.newCachedThreadPool();
     for (int i = 0; i <10 ; i++) {
        executorService.execute(new Runnable() {
           @Override
           public void run() {
            System.out.println("线程名："+Thread.currentThread().getName());
                }
            });
        }

③创建可以执行定时任务的线程池

//创建执行定时任务的线程池
 ScheduledExecutorService scheduledExecutorService= Executors.newScheduledThreadPool(2);
  System.out.println("设置定时任务之前"+new Date());
      // 执行定时任务
      //scheduleAtFixedRate：以上次任务的开始时间作为下次任务的开始时间
   scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
        @Override
         public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
             System.out.println("执行任务"+new Date());
              }
         },1,3, TimeUnit.SECONDS);

参数1：线程执行的任务Runnable
参数2：延迟一段时间执行
参数3：定时任务执行的频率
参数4：配合参数2和参数3使用的，它规定了时间的单位
注意：

④创建单线程执行定时任务的线程池

//创建单个线程池
   ScheduledExecutorService scheduledExecutorService= Executors.newSingleThreadScheduledExecutor();
    scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {
          @Override
          public void run() {
             System.out.println("执行任务"+new Date());
           }
       },1,3, TimeUnit.SECONDS);

⑤创建单个线程池

//创建单个线程的线程池
   ExecutorService service= Executors.newSingleThreadScheduledExecutor(); //同步执行
     for (int i = 0; i < 10; i++) {
        service.execute(new Runnable() {
           @Override
           public void run() {
              System.out.println("线程名："+Thread.currentThread().getName());
                }
            });
        }

经典面试题：创建单个线程池有什么用？

1.可以避免频繁的创建和销毁线程带来的性能开销。
2.有任务队列可以存储多余的任务。
3.当大量的任务不能处理的时候，可以友好的执行拒绝策略。
4.线程池可以很好的管理任务。

⑥根据当前的硬件CPU生成对应个数的线程池，并且是异步处理。（JDK8+）

最大生成的线程数=当前电脑的CPU核数

//创建一个异步根据当前CPU产生的线程池
      ExecutorService service= Executors.newWorkStealingPool(); //异步处理
        for (int i = 0; i < 10; i++) {
            service.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程名:"+Thread.currentThread().getName());
                }
            });
        }
        //等待线程池执行完成
        while (!service.isTerminated()){
        }

如果使用前6种创建线程池的方式会导致的问题：

1.线程数量不可控（比如创建带缓存的线程池）
2.工作任务量不可控（Integer.MAX_VALUE）,可能会导致内存溢出（OOM）。

2.原始的线程池创建方式ThreadPoolExecutor()

（1）代码实现

public class ThreadDemo {
    private static SimpleDateFormat simpleDateFormat=new SimpleDateFormat("mm:ss");
    public static void main(String[] args) {
        //定义线程池
        ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(10,10,60,
                TimeUnit.SECONDS,new LinkedBlockingDeque<>(1000));
        for (int i = 0; i < 1001; i++) {
            final int finalI=i;
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    Date date=new Date(finalI*1000);
                    myFormatTime(date);
                }
            });
        }
    }
    private synchronized static void myFormatTime(Date date){
        String result=simpleDateFormat.format(date);
        System.out.println("时间："+result);
    }
}

注意事项： 最大的线程数必须大于等于核心线程数

（2）线程池的拒绝策略

（3）ThreadPoolExecutor执行流程：核心线程数、最大线程数、任务队列

（4）线程池执行的2种方式

• 1.执行任务无返回值：excute(new Runnable(){…});
• 2.执行任务有返回值：submit(Runnable 无返回值/Callable 有返回值)

（5)线程池终止的2种方式

//结束线程池
threadPoolExecutor.shutdown();
//立即终止线程池（线程池的任务不会执行完）
threadPoolExecutor.shutdownNow();

（6）线程池的状态（线程的状态不等于线程池的状态）