创建线程的多种方式

最新推荐文章于 2023-05-31 08:33:26 发布

韩顺平的小迷弟

最新推荐文章于 2023-05-31 08:33:26 发布

阅读量133

点赞数

分类专栏： juc基础文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_41246557/article/details/126506576

版权

juc基础专栏收录该内容

6 篇文章 0 订阅

订阅专栏

线程的创建方式

继承Thread类
实现Runnable接口
实现Callable接口
使用线程池

继承Thread类实现线程创建

java 是单继承机制，此方法常见线程不常用

public class ExtendThread extends Thread{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 通过继承Thread实现线程创建");
    }

    public static void main(String[] args) {
        ExtendThread t1 = new ExtendThread();
        ExtendThread t2 = new ExtendThread();
        t1.start();
        t2.start();
    }
}

在这里插入图片描述

实现Runnable接口创建线程

public class RunnableCreate implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 通过实现Runnable接口创建线程");
    }

    public static void main(String[] args) {
        RunnableCreate runnableCreate = new RunnableCreate();
        new Thread(runnableCreate).start();
        new Thread(runnableCreate).start();
    }
}

在这里插入图片描述

实现Callable接口创建线程

Callable 接口的特点如下(重点）

为了实现 Runnable，需要实现不返回任何内容的 run（）方法，而对于Callable，需要实现在完成时返回结果的 call（）方法。
call（）方法可以引发异常，而 run（）则不能。
为实现 Callable 而必须重写 call 方法
不能直接替换 runnable,因为 Thread 类的构造方法根本没有 Callable

Future 接口

当 call（）方法完成时，结果必须存储在主线程已知的对象中，以便主线程可以知道该线程返回的结果。为此，可以使用 Future 对象。
将 Future 视为保存结果的对象–它可能暂时不保存结果，但将来会保存（一旦Callable 返回）。Future 基本上是主线程可以跟踪进度以及其他线程的结果的一种方式。要实现此接口，必须重写 5 种方法，这里列出了重要的方法,如下:

public boolean cancel（boolean mayInterrupt）：用于停止任务。
如果尚未启动，它将停止任务。如果已启动，则仅在 mayInterrupt 为 true时才会中断任务。
public Object get（）抛出 InterruptedException，ExecutionException：用于获取任务的结果。
如果任务完成，它将立即返回结果，否则将等待任务完成，然后返回结果。
public boolean isDone（）：如果任务完成，则返回 true，否则返回 false
可以看到 Callable 和 Future 做两件事-Callable 与 Runnable 类似，因为它封装了要在另一个线程上运行的任务，而 Future 用于存储从另一个线程获得的结果。实际上，future 也可以与 Runnable 一起使用。要创建线程，需要 Runnable。为了获得结果，需要 future。

FutureTask

Java 库具有具体的 FutureTask 类型，该类型实现 Runnable 和 Future，并方便地将两种功能组合在一起。可以通过为其构造函数提供 Callable 来创建FutureTask。然后，将 FutureTask 对象提供给 Thread 的构造函数以创建Thread 对象。因此，间接地使用 Callable 创建线程。

核心原理：（重点）
在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给 Future 对象在后台完成

当主线程将来需要时，就可以通过 Future 对象获得后台作业的计算结果或者执行状态
一般 FutureTask 多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。
仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法
一旦计算完成，就不能再重新开始或取消计算
get 方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常
get 只计算一次,因此 get 方法放到最后

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

public class CallableCreate implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + "线程正在执行");
        TimeUnit.SECONDS.sleep(5);
        return 1024;
    }

    public static void main(String[] args) {
        CallableCreate callableCreate = new CallableCreate();
        FutureTask<Integer> futureTask = new FutureTask(callableCreate);
        new Thread(futureTask,"线程一").start();
        System.out.println("主线程正在运行");
        for (int i = 0; i < 5; i++) {
            try {
                Integer res = futureTask.get();
                TimeUnit.SECONDS.sleep(1);
                System.out.println("res" +i + ":" + res);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        System.out.println("主线程over");
    }
}

在这里插入图片描述

小结(重点):

在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给 Future 对象在后台完成, 当主线程将来需要时，就可以通过 Future对象获得后台作业的计算结果或者执行状态
一般 FutureTask 多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果
仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法。一旦计算完成，就不能再重新开始或取消计算。get 方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常。
只计算一次

使用线程池创建线程

线程池简介

线程池（英语：thread pool）：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。
线程池的优势： 线程池做的工作只要是控制运行的线程数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。
它的主要特点为：

降低资源消耗: 通过重复利用已创建的线程降低线程创建和销毁造成的销耗。
提高响应速度: 当任务到达时，任务可以不需要等待线程创建就能立即执行。
提高线程的可管理性: 线程是稀缺资源，如果无限制的创建，不仅会销耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
Java 中的线程池是通过 Executor 框架实现的，该框架中用到了 Executor，Executors，ExecutorService，ThreadPoolExecutor 这几个类

线程池参数说明

corePoolSize 线程池的核心线程数
maximumPoolSize 能容纳的最大线程数
keepAliveTime 空闲线程存活时间
unit 存活的时间单位
workQueue 存放提交但未执行任务的队列
threadFactory 创建线程的工厂类
handler 等待队列满后的拒绝策略

线程池中，有三个重要的参数，决定影响了拒绝策略：corePoolSize - 核心线程数，也即最小的线程数。workQueue - 阻塞队列。 maximumPoolSize -最大线程数
当提交任务数大于 corePoolSize 的时候，会优先将任务放到 workQueue 阻塞队列中。当阻塞队列饱和后，会扩充线程池中线程数，直到达到maximumPoolSize 最大线程数配置。此时，再多余的任务，则会触发线程池的拒绝策略了。
总结起来，也就是一句话，当提交的任务数大于（workQueue.size() +maximumPoolSize ），就会触发线程池的拒绝策略。

拒绝策略(重点)

CallerRunsPolicy: 当触发拒绝策略，只要线程池没有关闭的话，则使用调用线程直接运行任务。一般并发比较小，性能要求不高，不允许失败。但是，由于调用者自己运行任务，如果任务提交速度过快，可能导致程序阻塞，性能效率上必然的损失较大.
AbortPolicy: 丢弃任务，并抛出拒绝执行 RejectedExecutionException 异常信息。线程池默认的拒绝策略。必须处理好抛出的异常，否则会打断当前的执行流程，影响后续的任务执行。
**DiscardPolicy: **直接丢弃，其他啥都没有
**DiscardOldestPolicy: **当触发拒绝策略，只要线程池没有关闭的话，丢弃阻塞队列 workQueue 中最老的一个任务，并将新任务加入

线程池的种类与创建

newCachedThreadPool(常用)
newFixedThreadPool(常用)
newSingleThreadExecutor(常用)

newCachedThreadPool(常用)

作用:创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程.
特点

线程池中数量没有固定，可达到最大值（Interger. MAX_VALUE）
线程池中的线程可进行缓存重复利用和回收（回收默认时间为 1 分钟）
当线程池中，没有可用线程，会重新创建一个线程

代码

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//演示线程池三种常用分类
public class ThreadPoolDemo1 {
    public static void main(String[] args) {
        //一池可扩容线程
        ExecutorService threadPool3 = Executors.newCachedThreadPool();
        //10个顾客请求
        try {
            for (int i = 1; i <= 20; i++) {
                threadPool3.execute(()->{
                    System.out.println(Thread.currentThread().getName()+ " 正在办理业务");
                });
            }
        }finally {
            System.out.println("我是来关闭的");
            //关闭
            threadPool3.shutdown();
        }

    }
}

在这里插入图片描述

场景: 适用于创建一个可无限扩大的线程池，服务器负载压力较轻，执行时间较短，任务多的场景

newFixedThreadPool(常用)

作用：创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。
特点

线程池中的线程处于一定的量，可以很好的控制线程的并发量
线程可以重复被使用，在显示关闭之前，都将一直存在
超出一定量的线程被提交时候需在队列中等待

代码

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//演示线程池三种常用分类
public class ThreadPoolDemo1 {
    public static void main(String[] args) {
        //一池N线程
        ExecutorService threadPool1 = Executors.newFixedThreadPool(5);
        //10个顾客请求
        try {
            for (int i = 1; i <= 20; i++) {
                threadPool1.execute(()->{
                    System.out.println(Thread.currentThread().getName()+ " 正在办理业务");
                });
            }
        }finally {
            System.out.println("我是来关闭的");
            //关闭
            threadPool1.shutdown();
        }

    }
}

在这里插入图片描述
场景: 适用于可以预测线程数量的业务中，或者服务器负载较重，对线程数有严格限制的场景

newSingleThreadExecutor(常用)

作用：创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。（注意，如果因为在关闭前的执行期间出现失败而终止了此单个线程，那么如果需要，一个新线程将代替它执行后续的任务）。可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。与其他等效的newFixedThreadPool 不同，可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。
特征

线程池中最多执行 1 个线程，之后提交的线程活动将会排在队列中以此执行

代码

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//演示线程池三种常用分类
public class ThreadPoolDemo1 {
    public static void main(String[] args) {
        //一池一线程
        ExecutorService threadPool2 = Executors.newSingleThreadExecutor();

        //10个顾客请求
        try {
            for (int i = 1; i <= 20; i++) {
                threadPool2.execute(()->{
                    System.out.println(Thread.currentThread().getName()+ " 正在办理业务");
                });
            }
        }finally {
            System.out.println("我是来关闭的");
            //关闭
            threadPool2.shutdown();
        }

    }
}

在这里插入图片描述
场景: 适用于需要保证顺序执行各个任务，并且在任意时间点，不会同时有多个线程的场景

线程池底层工作原理（重要）

在这里插入图片描述

在创建了线程池后，线程池中的线程数为零
当调用 execute()方法添加一个请求任务时，线程池会做出如下判断：
1. 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务；
2. 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列；
3. 如果这个时候队列满了且正在运行的线程数量还小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务；
4. 如果队列满了且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会启动饱和拒绝策略来执行。
当一个线程完成任务时，它会从队列中取下一个任务来执行
当一个线程无事可做超过一定的时间（keepAliveTime）时，线程会判断：
1. 如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。
2. 所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。

注意事项(重要)

项目中创建多线程时，使用常见的三种线程池创建方式，单一、可变、定长都有一定问题，原因是 FixedThreadPool 和 SingleThreadExecutor 底层都是用LinkedBlockingQueue 实现的，这个队列最大长度为 Integer.MAX_VALUE，容易导致 OOM。所以实际生产一般自己通过 ThreadPoolExecutor 的 7 个参数，自定义线程池
创建线程池推荐使用 ThreadPoolExecutor 及其 7 个参数手动创建
- corePoolSize 线程池的核心线程数
- maximumPoolSize 能容纳的最大线程数
- keepAliveTime 空闲线程存活时间
- unit 存活的时间单位
- workQueue 存放提交但未执行任务的队列
- threadFactory 创建线程的工厂类
- handler 等待队列满后的拒绝策略
为什么不允许使用 Executors.的方式手动创建线程池,如下图

自定义线程池入门案例

场景:火车站 3 个售票口, 10 个用户买票

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 火车站 3 个售票口, 10 个用户买票
 */
public class ThreadPoolDemo3 {
    public static void main(String[] args) {
        ThreadPoolExecutor threadService = new ThreadPoolExecutor(3,
                5,
                60L,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(4),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy());
        try{
            //10个人买票
            for (int i = 1; i <= 10; i++) {
                threadService.execute(() -> {

                    try {
                        System.out.println(Thread.currentThread().getName() + "窗口，开始买票");
                        TimeUnit.SECONDS.sleep(5);
                        System.out.println(Thread.currentThread().getName() + "窗口，结束买票");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //完成时结束
            threadService.shutdown();
        }
    }
}