Java线程池的基本了解

「爱情、让人受尽委屈。」 2024-03-24 13:18 104阅读 0赞

为什么要引入线程池?

首先,对于进程来说,系统的创建和销毁进程的开销太大了, 因此解决方案就是进程池 或者 线程 ,

但是再进一步,线程虽然比进程轻了,但是如果创建和销毁的频率进一步的增加, 仍然会发现开销依旧很大, 因此就引入了线程池 这一方面的概念.

### 线程池: ###

#### 线程池变快的原因 ####

首先了解用户态和内核态

用户态:

自己的代码也就是最上面的应用程序 这一层来运行的,这里的代码统称为"用户态" 运行的代码.

内核态:

例如System.out.println方法 本质需要经过write系统调用, 进入内核中, 内核执行一堆逻辑,控制显示器输出字符串,

这种再内核宗运行的代码 统称为"内核态"代码

创建线程本身就需要内核的支持,(创建线程本质是再内核中搞一个PCB , 加到链表内)

调用Thread.start 其实归根结底 也是 要进入内核态来运行.

而把创建好的线程放进"池子"里面 由于池子是用户态实现的,放到这个池/从池子取 这个过程中不需要涉及到内核态,就是存粹的用户态代码就能完成.

一般认为 纯用户态的操作,效率要比经过内核态处理的操作效率要更高.

也就是线程池中的线程一直保存在里面 , 不会被内核回收,等待程序调用.

#### 线程池的优点: ####

1.  **降低资源消耗**：减少线程的创建和销毁带来的性能开销。
2.  **提高响应速度**：当任务来时可以直接使用，不用等待线程创建
3.  **可管理性**： 进行统一的分配，监控，避免大量的线程间因互相抢占系统资源导致的阻塞现象。

--------------------

#### 线程池的使用 ####

线程池的构造方法有四种:

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;
    }
        
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }
    
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }

其中线程池的构造方法的参数有:

*  int corePoolSize : **允许存在的核心线程数**,即使这些线程没有被调用 , 也会被保留 不被销毁
 *  int maxnumPoolSize : **允许存在的最大线程数**, 当核心线程来不及调用执行任务的时候, 会额外创建其他的线程,来进行任务的执行.
 *  long keepAliveTime : **临时创建出来的线程的存活时间**, 时间一到这些临时创建出来的线程就会被销毁.
 *  TimeUnit unit : 指定 keepAliveTime 的**单位**
 *  BlockingQueue workQueue : \*\*任务队列,\*\*线程池会提供一个submit方法来进行提交任务到该任务队列里面, 线程池里面的线程就可以从这个工作队列里面拿取任务然后执行.
 *  ThreadFactory threadFactory : **创建线程的工厂方式**
 *  RejectedExecutionHandler handler : **拒绝策略.**

#### 线程池的参数 ####

##### 线程池的拒绝策略 : #####

*   *  `ThreadPoolExecutor.AbortPolicy` : **直接抛出一个 `RejectedExecutionException` 异常**
     *  `ThreadPoolExecutor.CallerRunsPolicy` :哪个线程调用的这个任务, 那么就让该线程执行, **本身收到任务线程不执行该任务**
     *  `ThreadPoolExecutor.DiscardPolicy` : **丢弃最新任务**,执行接收到的任务.
     *  `ThreadPoolExecutor.DiscardOldestPolicy` : **丢弃最老任务**, 执行收到的任务.

#### 线程池的简化版本: ####

提供了另一种类 Excutors , 本质上是针对ThreadPoolExecutor进行了封装 ,提供了一些参数

public class Pools {
        
        public static void main(String[] args) {
        
            ExecutorService pool = Executors.newFixedThreadPool(10);
            Executors.newCachedThreadPool();
            Executors.newSingleThreadExecutor(); 
            Executors.newScheduledThreadPool();
            pool.submit(new Runnable() {
        
                @Override
                public void run() {
        
                    for (int i = 0; i < 100; i++) {
        
                        System.out.println("hello threadPool");
                    }
                }
            });
        }
    }

*  newFixedThreadPool : 创建了一个\*\*固定线程数目的线程池,\*\*参数制定了线程个数
 *  newCachedThreadPool : 创建了一个**自动扩容的线程池**,会根据任务量来自动进行扩容
 *  newSingleThreadExecutor : 创建了一个**只有一个线程的线程池**
 *  newScheduledThreadPool :创建了一个**带有定时器功能的线程池** , 类似于Timer