Java基础之创建线程的几种方式, 线程池创建原理, 线程池核心参数

灰太狼 2023-06-22 13:49 8阅读 0赞

# 1. 什么是线程?线程和进程的区别? #

*  线程：**是进程的一个实体，是 cpu 调度和分派的基本单位，是比进程更小的可以独立运 行的基本单位**。
 *  进程：**具有一定独立功能的程序关于某个数据集合上的一次运行活动**，是操作系统进行资源分配和调度的一个独立单位。
    
    特点：线程的划分尺度小于进程，这使多线程程序拥有高并发性，进程在运行时各自内存 单元相互独立，线程之间内存共享，这使多线程编程可以拥有更好的性能和用户体验  
    注意：多线程编程对于其它程序是不友好的，占据大量 cpu 资源。

# 2. 创建线程的4种方式 #

**继承Thread类,实现Runnable接口,实现Callable接口,线程池**,共4中方法.

## 2.1 继承Thread ##

Thread 类本质上是实现了 Runnable 接口的一个实例，代表一个线程的实例。**启动线程的唯一方法就是通过Thread 类的 start()实例方法**。start()方法是一个 native 方法，它将启动一个新线程，并执行 run()方法

package com.acece.ThreadReview;
    
    /** * @author 啊策策 */
    //继承Thread类,创建线程
    public class CreateThreadFirst extends Thread{ 
        public void run(){ 
            System.out.println("CreateThreadFirst.run()");
        }
    
    }
    //测试线程
    class ThreadTest{ 
        public static void main(String[] args) { 
            CreateThreadFirst createThreadFirst = new CreateThreadFirst();
            createThreadFirst.start();
        }
    }

## 2.2 实现Runnable接口 ##

*  好处是,接口可以多实现,而继承Thread只能单继承
 *  本质上也是调用**run()方法**.

package com.acece.ThreadReview;
    /** * @author 啊策策 */
    public class CreateThreadSecond implements Runnable{ 
        public void run() { 
            System.out.println("CreateThreadSecond.run()...");
        }
    }
    
    //测试线程
    class ThreadTest{ 
        public static void main(String[] args) { 
            //2. 测试第二种方法
            CreateThreadSecond createThreadSecond = new CreateThreadSecond();
            Thread thread = new Thread(createThreadSecond);
            thread.start();
        }
    }

## 2.3 实现Callable接口 ##

*  **Java 5.0** 在 java.util.concurrent 提供了一个新的创建执行线程的方式：Callable 接口
 *  相对于Runnable接口,**Callable接口有返回值,而且也可以抛出经检测的异常.**
 *  Callable 需要依赖FutureTask ，FutureTask 也可以用作闭锁。

#### 具体步骤如下 ####

1.  实现Callable接口，实现其中的call方法。
2.  新建实现Callable接口的对象。
3.  新建FutureTask对象，其中参数是Callable接口对应的对象。
4.  新建Thread对象，其中参数是FutureTask对象。
5.  执行线程：Thread对象.start方法。
6.  FutureTask对象.get方法等待返回值。
7.  在线程结果没有被get到的时候，它会阻塞后面的内容，也可以用于闭锁。

package com.acece.ThreadReview;
    
    import java.util.concurrent.*;
    
    /** * @author 啊策策 */
    //1. 创建一个类实现Callable接口,实现call()方法,
    public class CreateThreadFourth implements Callable<Integer>{ 
    
        //新增返回值(接口的泛型上体现),新增了可抛出异常
        public Integer call() throws Exception { 
            int sum = 0;
            for (int i = 0; i < 10; i++) { 
                sum += i;
                System.out.println(i);
            }
            return sum;
        }
    }
    
    //创建一个类,测试CreateThreadThird
    class CreateThreadThirdTest{ 
        public static void main(String[] args) { 
            long sum = 0;
    
            //2. 新建实现Callable接口类的对象
            CreateThreadThird createThreadThird = new CreateThreadThird();
    
            //3. 新建FutureTask对象,其中参数是Callable接口对应的对象.
            FutureTask<Integer> task = new FutureTask<Integer>(createThreadThird);
    
            //4. 新建Thread对象,其中参数是FutureTask对象.
            //5. 执行线程: Thread对象.start方法
            new Thread(task).start();
    
            //6.FutureTask对象.get方法等待返回值.
            try { 
                sum = task.get();
            } catch (Exception e) { 
                e.printStackTrace();
            }
            //7.在线程结果没有被get到的时候,它会阻塞后面的内容,也可以用于闭锁.
            System.out.println("总和是: " + sum);
        }
    }

## 2.4 通过线程池创建线程 ##

**线程池就是事先将多个线程对象放到一个容器中，当使用的时候就不用 new 线程而是直接去池中拿线程即可**，节省了开辟子线程的时间，提高的代码执行效率。 在 JDK 的 java.util.concurrent.Executors 中提供了生成多种线程池的静态方法.  
![在这里插入图片描述][20191216185209194.png]  
然后再调用线城池的 execute 方法, 传递new Runnable()参数重写run()方法即可.

### 2.4.1 常见的线程池有几种? ###

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

*  **newCachedThreadPool**：创建一个可缓存的线程池，此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说 JVM）能够创建的最大线程大小。
 *  **newFixedThreadPool**：**创建固定大小的线程池**，每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。
 *  **newSingleThreadExecutor**：**创建一个单线程的线程池**，此线程池保证所有任务的执行顺序 按照任务的提交顺序执行。
 *  **newSingleThreadScheduleExecutor**: 创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期执行.
 *  **newScheduledThreadPool**：创建一个线程池，它可安排在给定延迟后运行命令或者定期的执行, 线城池数量不固定.
 *  **newWorkStealingPool**: 创建一个带并行级别的线程池，并行级别决定了同一时刻最多有多少个线程在执行，如不传并行级别参数，将默认为当前系统的CPU个数.

### 2.5.2 线城池执行原理 ###

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

*  用户提交任务
 *  先判断当前线程数是否大于核心线程数
    
     *  如果没有大于, 则直接利用核心线程执行任务
     *  如果大于, 则可是往**阻塞队列**中放入任务.
        
         *  如果阻塞队列没放满, 则随着核心线程完成老的任务之后, 就完成队列中的任务了.
         *  如果阻塞队列放满了. 开始创建新线程执行任务
            
             *  如果, 新线程数量+核心线程数量小于等于最大线程数, 利用新线程和核心线程分摊任务.
             *  如果, 新线程数量+核心线程数量大于最大线程数, 则报错, 执行拒绝策略.

### 2.5.3 线程池核心参数 ###

#### 默认参数： ####

corePoolSize = 1
    	queueCapacity = Integer.MAX_VALUE
    	maxPoolSize = Integer.MAX_VALUE
    	keepAliveTime = 60秒
    	unit:秒,分钟
    	allowCoreThreadTimeout = false
        ThreadFactory=Executors.defaultThreadFactory
    	rejectedExecutionHandler = AbortPolicy()

#### 具体讲解： ####

1.  corePoolSize（核心线程数）  
    (1)核心线程会一直存在，即使没有任务执行；  
    (2)当线程数小于核心线程数的时候，即使有空闲线程，也会一直创建线程直到达到核心线程数；  
    (3)核心线程数代表我能够维护常用的线程开销.
2.  maxPoolSize（最大线程数）  
    (1)线程池里允许存在的最大线程数量；  
    (2)线程池里允许存在的最大线程数量。当任务队列已满，且线程数量大于等于核心线程数时，会创建新的线程执行任务。
3.  queueCapacity（阻塞队列）  
    当核心线程都在运行，此时再有任务进来，会进入任务队列，排队等待线程执行。
4.  keepAliveTime（线程空闲时间）  
    (1)当线程空闲时间达到keepAliveTime时，线程会退出(关闭).  
    (2)如果allowCoreThreadTimeout=true，则线程会继续退出直到为0个。  
    (3)默认allowCoreThreadTimeout=false, 也就是说线程池中的线程退出, 直到=核心线程数.
5.  unit: 和keepAliveTime配合使用, 时间单位, 可以为秒, 分钟.
6.  allowCoreThreadTimeout（允许核心线程超时, 默认为false, jdk1.6后加的新特性)
7.  ThreadFactory:  
    线程创建的工厂，新的线程都是由ThreadFactory创建的，系统默认使用的是  
    Executors.defaultThreadFactory创建的，用它创建出来的线程的优先级、组等都是一样  
    的，并且他都不是守护线程。我们也可以使用自定义的线程创建工厂，并对相关的值进  
    行修改
8.  rejectedExecutionHandler（任务拒绝处理器）  
    (1)当线程数量达到最大线程数，且任务队列已满时，会拒绝任务；  
    (2)调用线程池shutdown()方法后，会等待执行完线程池的任务之后，再shutdown()。如果在调用了shutdown()方法和线程池真正shutdown()之间提交任务，会拒绝新任务。

### 2.5.4 拒绝策略 ###

线程池中的线程已经用完了，无法继续为新任务服务，同时，等待队列也已经排满了， 再也塞不下新任务了。这时候我们就需要拒绝策略机制合理的处理这个问题。

*  **ThreadPoolExecutor.AbortPolicy（系统默认）**： 丢弃任务并抛出RejectedExecutionException异常，让你感知到任务被拒绝了，我们可以根据业务逻辑选择重试或者放弃提交等策略
 *  ThreadPoolExecutor.DiscardPolicy： 也是丢弃任务，但是不抛出异常，相对而言存在一定的风险，因为我们提交的时候根本不知道这个任务会被丢弃，可能造成数据丢失。
 *  ThreadPoolExecutor.DiscardOldestPolicy： 丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程），通常是存活时间最长的任务，它也存在一定的数据丢失风险
 *  ThreadPoolExecutor.CallerRunsPolicy： 由调用线程处理该任务

### 2.5.5 使用线程池的好处? ###

第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。  
第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。  
第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源， 还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控.

### 2.5.6 如果关闭线城池 ###

*  刚才提过线城池核心参数, 设置时间, 会自动关闭
 *  shutdownNow()：线程池拒接收新提交的任务，同时立马关闭线程池，线程池里的任务不再执行.
 *  showdown(): 线程池拒接收新提交的任务，同时等待线程池里的任务执行完毕后关闭线程池。

[20191216185209194.png]: https://img-blog.csdnimg.cn/20191216185209194.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjY0MTkwOQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20201226180002954.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjY0MTkwOQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjY0MTkwOQ_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20201227170121183.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjY0MTkwOQ==,size_16,color_FFFFFF,t_70#pic_center