Java线程池是什么?模拟一个简单的Java线程池

一、 前言

为了实现并发编程,于是就引入了进程这个概念。进程就相当于操作系统的一个任务。多个进程同时执行任务,就实现了并发编程,能够更快的执行。

但是由于进程还不够轻量,创建一个进程,销毁一个进程消耗的资源不可忽视。如果进程数量不多的情况下,这些资源消耗是可以接受的,但是如果频繁的创建、销毁进程。就是一笔很大的开销了。

那要怎么办呢?


为了解决这个问题,人们引入了更轻量的工具——线程。
线程也被称为轻量级进程。它的创建、销毁比进程消耗的资源更少。但是如果任务数量很多,多线程也顶不住频繁的创建、销毁了呢?这时线程池就出来解决问题了!

关于线程、进程。这里有更详细的介绍哦。
传送门在这里

二、线程池是什么?

线程池是类似于Java字符串常量池一样的东西。


使用线程VS不使用线程
  • 当使用一个线程的时候,就直接从池子里取一个线程过来。
  • 当不用一个线程的时候就把这个线程放到池子里,

  • 这样可能大家还不是很明白到底线程池是啥。在给大家举一个更形象的例子。 找工作!❤️

    大家都知道找工作的流程大概是这样的。

  • 投简历-笔试-面试-offer
  • 当我们到面试完了之后,会有两种情况。

    1. 通过了,公司打电话通知你,给你发offer
    2. 没通过,而且一般公司也不告诉你自己没过,而是完全没通知你没有过,这是因为公司可能会把你放到他们的"人才贮备池"里了。
    假设公司要找50个人,在秋招的时候,给50个人发了offer。 但是实际上,只有35个人来入职报道了。这时候,剩下的15个人就从人才贮备池里直接捞出15个,直接发offer。

  • 这时候可能过了一段时间,公司突然打电话通知你,你被录用了,要不要来?这个操作就相当于一个线程要被使用到了,直接从池子里拿出来用。

  • 这就是用找工作的例子形容了一下线程池大概是什么意思。

    三、线程池构造方法ThreadPoolExecutor的构造方法的参数都是啥意思?

    在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供,不允许在应用中自行显示的创建线程,这样一方面是线程的创建更加规范,可以合理控制开辟线程的数量;另一方面线程的细节管理交给线程池处理,优化了资源的开销。

    "ThreadPoolExecutor"这个类是Java标准库提供的一组类,用来使用线程池。

    ThreadPoolExecutor的构造方法有四个。分别含有不同的参数,使用的场景也不同。
    我们就以参数最多的构造方法来介绍。

    ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor (
    int corePoolSize,
    int maximumPoolSize ,
    long keepAliveTime ,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue,
     ThreadFactory threadFactory,
     RejectedExecutionHandler handler
     )
    

    在这里插入图片描述

    1. corePoolSize 核心线程数
    2. maximumPoolSize 最大线程数

      对于核心线程数和最大线程数可能不是很理解到底是干嘛的,这里举一个员工上班的例子。

      核心线程数,就是公司里的正式员工,允许他们可以摸鱼一会。 被发现了不至于开除。(相当于线程池中的线程就算什么也不干也不会被销毁)

      最大线程数,就是公司里的正式员工+临时工组成的数量,但是这里的临时工摸鱼到了一定时间了就要被开除。(相当于线程池中的线程被销毁)

    3. keepAliveTime 描述临时工能摸鱼多长时间的
    4. unit 是一个时间单位,也就是keepAliveTime的单位。
    5. workQueue 阻塞队列,就组织了线程池要执行的任务
    6. threadFactory 线程的创建方式,通过这个参数来设定不同线程的创建方式
    7. RejectedExecutionHandler handler 拒绝策略。当任务队列满了的时候,新任务又来了,这时候咋办?

    (1):最新的任务不要了
    (2):最老的任务不要了
    (3):阻塞等待
    (4)开摆:抛出异常

    由于ThreadPoolExecutor使用起来比较复杂,最多有7个参数。标准库为此又为程序员们提供了一组其他的类。相当于对ThreadPoolExecutor又进行了一层封装。

    1. newFixedThreadPool:创建出一个固定线程数量的线程池。
     ExecutorService Service1   =  Executors.newFixedThreadPool (20);
    

    newCachedThreadPool:创建出一个数量可变的线程池

    ExecutorService Service2   = Executors.newCachedThreadPool ();
    

    newSingleThreadExecutor:创建只有一个线程的线程池

    ExecutorService Service3  = Executors.newSingleThreadExecutor ();
    

    newScheduledThreadPool:创建一个能设定延时时间的线程池。

    ExecutorService Service4   = Executors.newScheduledThreadPool (20);
    

      四、模拟实现一个线程池

      模拟实现一个线程池的核心操作:
      .:将任务加到线程池中--submit。
      .:使用Worker类描述一个工作线程,Runnable来描述一个任务。
      .:创建一个BlockingQueue阻塞队列组织所有任务。
      .:每个Worker要做的事情就是不停的从阻塞队列里获取任务并执行。
      .:指定线程池中的线程最大数目,如果超过这个数目就不要再继续创建线程了。
      

      代码实现:

      我们创建一个线程池并让它不停的创建进程打印hello

      import java.io.IOException;
      import java.util.ArrayList;
      import java.util.List;
      import java.util.concurrent.BlockingQueue;
      import java.util.concurrent.LinkedBlockingQueue;
      import java.util.concurrent.ThreadPoolExecutor;
      
      /**
       * Created with IntelliJ IDEA.
       *
       
       * @Description: 模拟实现线程池的使用
       */
      public class ThreadDemo0327_2 {
          public static void main (String[] args) throws IOException, InterruptedException {
              ThreadPoll threadPoll=new ThreadPoll ();
              for (int i = 0 ; i <10  ; i++) {
                  threadPoll.submit (new Runnable () {
                      @Override
                      public void run () {
                          System.out.println ("hello");
                      }
                  });
              }
          }
      }
      
      class  Worker extends  Thread{
          public   BlockingQueue<Runnable> queue=null;
          public Worker(BlockingQueue<Runnable> queue){
              this.queue=queue;
          }
      
          @Override
          public void run () {
              //工作线程的具体逻辑
              //需要从阻塞队列中取任务.
              while (true){
                  try {
                      Runnable command=queue.take ();
                      //通过run来执行具体任务
                      command.run ();
                  }catch (InterruptedException e){
                      e.printStackTrace ();
                  }
              }
          }
      }
      
      class  ThreadPoll{
          //包含一个阻塞队列,用来组织任务
        public   BlockingQueue<Runnable> queue=new LinkedBlockingQueue<> ();
      
          //这个list就用来存放当前的工作线程.
          public  List<Thread> works=new ArrayList<> ();
      
          public  int MAX_WORKER_COUNT=10;
      
          //通过这个方法,把任务加入到线程池中
          //submit不光可以把任务放到阻塞队列中,也可以负责创建线程
          public  void submit(Runnable command) throws IOException, InterruptedException {
              if(works.size ()<MAX_WORKER_COUNT){
                  //如果当前工作线程的数量不足线程数目上线,就创建出新的线程
                  //工作线程就专门找一个类完成
                  //worker内部要哦能够取到队列的内容,就要把这个队列实例通过worker的构造方法传过去
                  Worker worker=new Worker (queue);
                  worker.start ();
                  works.add (worker);
              }
              queue.put (command);
          }
      }
      

      运行效果:
      可以看到,打印了10个hello。
      Java线程池是什么?模拟一个简单的Java线程池_第1张图片

      这篇文章到这里就结束了,希望能帮助到你哟。

    你可能感兴趣的:(JavaEE,java,后端,intellij-idea)