Java Spring多线程

news2024/11/25 14:38:43

Java Spring多线程

  • 开启一个线程
    • 1 继承java.lang.Thread类
    • 2 实现java.lang.Runnable接口
    • 3 实现Callable接口
    • 4 实现线程池ThreadPoolExecutor
  • Java线程池
    • Executors 的类型
    • Future与线程池

开启一个线程

https://blog.csdn.net/qq_44715943/article/details/116714584

1 继承java.lang.Thread类

  1. 编写一个类，直接 继承 java.lang.Thread，重写 run方法，run方法为这个线程要做的事情。
  2. 创建线程对象， new继承线程的类。
  3. 启动线程，调用线程对象的 start() 方法。
public class ThreadTest02 {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        // 启动线程
        //t.run(); // 不会启动线程，不会分配新的分支栈。（这种方式就是单线程。）
        t.start();
        // 这里的代码还是运行在主线程中。
        for(int i = 0; i < 1000; i++){
            System.out.println("主线程--->" + i);
        }
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        // 编写程序，这段程序运行在分支线程中（分支栈）。
        for(int i = 0; i < 1000; i++){
            System.out.println("分支线程--->" + i);
        }
    }
}

注意：

  • t.run() 不会启动线程，只是普通的调用方法而已。不会分配新的分支栈。（这种方式就是单线程。）
  • t.start() 方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。线程就启动成功了。启动成功的线程会自动调用run方法。 run方法在分支栈的栈底部（压栈）main方法在主栈的栈底部，run和main是平级的。

2 实现java.lang.Runnable接口

  1. 编写一个类，实现 java.lang.Runnable 接口，实现run方法，run方法为这个线程要做的事情（同1）。
  2. 创建线程对象，new线程类传入可运行的类/接口。
  3. 启动线程呢，调用线程对象的 start() 方法（同1）。
public class ThreadTest03 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable()); 
        // 启动线程
        t.start();
        
        for(int i = 0; i < 100; i++){
            System.out.println("主线程--->" + i);
        }
    }
}

// 这并不是一个线程类，是一个可运行的类。它还不是一个线程。
class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            System.out.println("分支线程--->" + i);
        }
    }
}

优势：

  • 实现的方式没有类的单继承性的局限性：一个类实现了接口，它还可以去继承其它的类，更灵活。
  • 实现的方式更适合来处理多个线程有共享数据的情况

3 实现Callable接口

  1. 创建一个实现Callable的实现类
  2. 实现call方法，将此线程需要执行的操作声明在call()中
  3. 创建Callable接口实现类的对象
  4. 将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
  5. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
  6. 获取Callable中call方法的返回值
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//1.创建一个实现Callable的实现类
class NumThread implements Callable {
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        //把100以内的偶数相加
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadNew {
    public static void main(String[] args) {    
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);

        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

优势：

  • call()可以有返回值的
  • call()可以抛出异常，被外面的操作捕获，获取异常的信息
  • Callable是支持泛型的

4 实现线程池ThreadPoolExecutor

  1. 创建好实现了Runnable接口的类或实现Callable的实现类
  2. 实现run或call方法
  3. 创建线程池
  4. 调用线程池的execute方法执行某个线程，参数是之前实现Runnable或Callable接口的对象
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

class NumberThread implements Runnable {
    @Override
    public void run() {
        //遍历100以内的偶数
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class NumberThread1 implements Runnable {
    @Override
    public void run() {
        //遍历100以内的奇数
        for (int i = 0; i <= 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

public class ThreadPool {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);

        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //自定义线程池的属性
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();

        //2. 执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适用于Runnable
        service.execute(new NumberThread1());//适用于Runnable
//        service.submit(Callable callable);//适合使用于Callable

        //3. 关闭连接池
        service.shutdown();
    }
}

Java线程池

如果我们不采用线程池，为每一个请求都创建一个线程的话：

  1. 管理线程的生命周期开销非常高。管理这些线程的生命周期会明显增加 CPU 的执行时间，会消耗大量计算资源。
  2. 线程间上下文切换造成大量资源浪费。
  3. 程序稳定性会受到影响。我们知道，创建线程的数量存在一个限制，这个限制将随着平台的不同而不同，并且受多个因素制约，包括jvm的启动参数、Thread构造函数中请求的栈大小，以及底层操作的限制等。如果超过了这个限制，那么很可能抛出OutOfMemoryError异常，这对于运行中的应用来说是非常危险的。

Java自JDK1.5 提供了自己的多线程框架，称为 Executor框架.
在这里插入图片描述

  • Executor：java线程池框架的最上层父接口，在Executor这个接口中只有一个execute方法，该方法的作用是向线程池提交任务并执行。
  • ThreadPoolExecutor：这是Java线程池最核心的一个类，该类继承自AbstractExecutorService，主要功能是创建线程池，给任务分配线程资源，执行任务。
  • ScheduledExecutorSerivce 和 ScheduledThreadPoolExecutor 提供了另一种线程池：延迟执行和周期性执行的线程池。
  • Executors：这是一个静态工厂类，该类定义了一系列静态工厂方法，通过这些工厂方法可以返回各种不同的线程池。
  • ExecutorService：该接口继承自Executor接口，添加了shutdown、shutdownAll、submit、invokeAll等一系列对线程的操作方法，该接口比较重要，在使用线程池框架的时候，经常用到该接口。
  • AbstractExecutorService:这是一个抽象类，实现ExecuotrService接口

Executors 的类型

  1. SingleThreadExecutor: 此线程池 Executor 只有一个线程。它用于以顺序方式的形式执行任务。如果此线程在执行任务时因异常而挂掉，则会创建一个新线程来替换此线程，后续任务将在新线程中执行。
ExecutorService executorService = Executors.newSingleThreadExecutor()
  1. FixedThreadPool(n): 它是一个拥有固定数量线程的线程池。提交给 Executor 的任务由固定的 n 个线程执行，如果有更多的任务，它们存储在 LinkedBlockingQueue 里。这个数字 n 通常跟底层处理器支持的线程总数有关。
ExecutorService executorService = Executors.newFixedThreadPool(4);

如果是CPU密集型任务，就需要尽量压榨CPU，参考值可以设为 NCPU+1 如果是IO密集型任务，参考值可以设置为2*NCPU

  1. CachedThreadPool: 该线程池主要用于执行大量短期并行任务的场景。与固定线程池不同，此线程池的线程数不受限制。如果所有的线程都在忙于执行任务并且又有新的任务到来了，这个线程池将创建一个新的线程并将其提交到 Executor。只要其中一个线程变为空闲，它就会执行新的任务。 如果一个线程有 60 秒的时间都是空闲的，它们将被结束生命周期并从缓存中删除。

    但是，如果管理得不合理，或者任务不是很短的，则线程池将包含大量的活动线程。这可能导致资源紊乱并因此导致性能下降。

ExecutorService executorService = Executors.newCachedThreadPool();
  1. ScheduledExecutor：当我们有一个需要定期运行的任务或者我们希望延迟某个任务时，就会使用此类型的 executor。
ScheduledExecutorService scheduledExecService = Executors.newScheduledThreadPool(1);
scheduledExecService.scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
scheduledExecService.scheduleWithFixedDelay(Runnable command, long initialDelay, long period, TimeUnit unit)

Future与线程池

由于提交给Executor 的任务是异步的，需要有一个对象来接收Executor 的处理结果：

Future<String> result = executorService.submit(callableTask);

调用者可以继续执行主程序，当需要提交任务的结果时，他可以在这个 Future对象上调用.get() 方法来获取。如果任务完成，结果将立即返回给调用者，否则调用者将被阻塞，直到 Executor 完成此操作的执行并计算出结果。

如果调用者不能无限期地等待任务执行的结果，那么这个等待时间也可以设置为定时地。可以通过 Future.get(long timeout，TimeUnit unit) 方法实现，如果在规定的时间范围内没有返回结果，则抛出 TimeoutException。调用者可以处理此异常并继续执行该程序。

如果在执行任务时出现异常，则对 get 方法的调用将抛出一个ExecutionException。对于 Future.get()方法返回的结果，一个重要的事情是，只有提交的任务实现了java.util.concurrent.Callable接口时才返回 Future。如果任务实现了Runnable接口，那么一旦任务完成，对 .get() 方法的调用将返回 null。

另一点是 Future.cancel(boolean mayInterruptIfRunning) 方法。此方法用于取消已提交任务的执行。如果任务已在执行，则 Executor 将尝试在mayInterruptIfRunning 标志为 true 时中断任务执行。

创建Callable任务：

public class Task implements Callable<String> {

    private String message;

    public Task(String message) {
        this.message = message;
    }

    @Override
    public String call() throws Exception {
        return "Hello " + message + "!";
    }
}

异步执行任务：

public class ExecutorExample {  
    public static void main(String[] args) {
    	// 1. 实例化了 Task 类
        Task task = new Task("World");
        // 2. 创建了一个具有4个线程数的 FixedThreadPool Executors
        // 3. 提交给 Executors 执行
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        // 4. 结果由 Future 对象返回
        Future<String> result = executorService.submit(task);
        try {
            System.out.println(result.get());
        } catch (InterruptedException | ExecutionException e) {
            System.out.println("Error occured while executing the submitted task");
            e.printStackTrace();
        }
        // 调用 executorService 对象上的 shutdown 来终止所有线程并将资源返回给 OS
        executorService.shutdown();
    }
}

shutdown() 方法等待 Executor 完成当前提交的任务。 但是，如果要求是立即关闭 Executor 而不等待，那么我们可以使用 shutdownNow() 方法。

或者创建Runnable任务：

public class Task implements Runnable{

    private String message;

    public Task(String message) {
        this.message = message;
    }

    public void run() {
    	// 由于Runnable任务没有返回值，不能得到任务执行结果。需要在任务内完成所有操作（打印）
        System.out.println("Hello " + message + "!");
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/702688.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

React hooks文档笔记（二） 添加交互性

React hooks文档笔记（二） 添加交互性

添加交互性 1. 事件传播1.1 停止传播1.2 阻止默认事件 2. [Hook] useState 状态3. 渲染和提交3.1 触发渲染3.2 React渲染组件3.3 提交对 DOM 的更改3.4 浏览器绘制 4. 渲染快照状态队列例子 5. 更新state中的对象 1. 事件传播 js的事件流&#xff1a; 事件捕获&#xff1a;从…
阅读更多...
Spring学习(二)(Spring创建和使用)

Spring学习(二)(Spring创建和使用)

经过前⾯的学习我们已经知道了&#xff0c;Spring 就是⼀个包含了众多⼯具⽅法的 IoC 容器。既然是容器那么 它就具备两个最基本的功能&#xff1a; 将对象(Bean)存储到容器&#xff08;Spring&#xff09;中&#xff1b; 从容器中将对象取出来。那么该怎么将Bean存储的Spring以…
阅读更多...
单片机系统架构

单片机系统架构

单片机系统架构 单片机概述 微型计算机的组成 微处理器、存储器加上I/O接口电路组成微型计算机。各部分通过地址总线&#xff08;AB&#xff09;、数据总线&#xff08;DB&#xff09;和控制总线&#xff08;CB&#xff09;相连。 微型计算机的应用形态 ​ 从应用形态上&am…
阅读更多...
python数据可视化-日期折线图画法

python数据可视化-日期折线图画法

引入 什么是折线图&#xff1a; 折线图是排列在工作表的列或行中的数据可以绘制到折线图中。折线图可以显示随时间&#xff08;根据常用比例设置&#xff09;而变化的连续数据&#xff0c;因此非常适用于显示在相等时间间隔下数据的趋势。 在折线图中&#xff0c;类别数…
阅读更多...
【vue】- 简易版筛选组件可展开/收起

【vue】- 简易版筛选组件可展开/收起

仅做记录&#xff0c;未整理格式 css部分未完全&#xff0c;每个筛选条件为固定宽度 实现效果 单行筛选条件时不触发更多按钮&#xff0c;且做占位处理 多行筛选条件时默认收起 同时设定最大/最小宽度并监听该组件宽度变化 filter.vue组件 <template><div :cla…
阅读更多...
c#调用c++ dll，Release版本内存访问错误

c#调用c++ dll，Release版本内存访问错误

最近遇到个比较经典的案例&#xff0c;在c#中调用yara进行文件检测&#xff0c;yara是c编写的一个非常强大库&#xff0c;github有个大佬用c#对其进行了封装&#xff0c;使其能在跨平台下&#xff0c;只需编译yara的so或dll就能直接跑。但总是在Release版本下时不时就崩溃&…
阅读更多...
Hadoop 组成

Hadoop 组成

4 Hadoop 优势（4 高） 1）高可靠性：Hadoop底层维护多个数据副本，所以即使Hadoop某个计算元素或存储出现故障，也不会导致数据的丢失。 2）高扩展性：在集群间分配任务数据，可方便的扩展数以千计的节点。 3）高效性：在MapReduce的思想下，Hadoop是并行工作的，以加快任务…
阅读更多...
低代码平台在ERP软件中的作用

低代码平台在ERP软件中的作用

很多人认为 低代码开发平台的出现颠覆了传统的软件开发模式&#xff0c;对软件开发行业造成冲击&#xff0c;其实低代码开发平台的出现只是提高了软件开发的效率&#xff0c;并不是要颠覆软件开发的模式。低代码平台在erp软件开发中的作用还是比较明显的。下面一起来了解一下相…
阅读更多...
Postman Mock快速入门

Postman Mock快速入门

目录 前言&#xff1a; 1.Mock简介 1.1 Mock定义 1.2 Mock目的 1.3 Mock意义 1.4 Mock服务 2. Postman 创建Mock服务 2.1 创建Mock服务 2.2 Postman创建Mock服务 2.2.1 Postman 创建Mock服务器参数 2.2.2 Postman创建Mock步骤 3.访问Postman Mock服务 前言&#xf…
阅读更多...
css基础知识十三：怎么理解回流跟重绘？什么场景下会触发？

css基础知识十三：怎么理解回流跟重绘？什么场景下会触发？

一、是什么 在HTML中&#xff0c;每个元素都可以理解成一个盒子&#xff0c;在浏览器解析过程中&#xff0c;会涉及到回流与重绘&#xff1a; 回流&#xff1a;布局引擎会根据各种样式计算每个盒子在页面上的大小与位置重绘&#xff1a;当计算好盒模型的位置、大小及其他属性…
阅读更多...
MySQL-SQL全部锁详解（下）

MySQL-SQL全部锁详解（下）

♥️作者&#xff1a;小刘在C站 ♥️个人主页&#xff1a; 小刘主页 ♥️努力不一定有回报&#xff0c;但一定会有收获加油&#xff01;一起努力&#xff0c;共赴美好人生&#xff01; ♥️学习两年总结出的运维经验&#xff0c;以及思科模拟器全套网络实验教程。专栏&#xf…
阅读更多...
老PM，到底在牛什么？

老PM，到底在牛什么？

早上好&#xff0c;我是老原。 “成长为一名优秀的项目经理。”相信这是每一个刚入行的项目经理都会立的flag。 对于项目经理来说&#xff0c;这是一个能力和经验并重的岗位&#xff0c;你应该也经常听人说&#xff0c;这项目经理是一个越老越吃香的职业。 就拿我自己来说&a…
阅读更多...
【java】HashMap扩容机制详解

【java】HashMap扩容机制详解

文章目录 JDK1.7下的扩容机制JDK1.8下的扩容机制 JDK1.7下的扩容机制 JDK1.7下的resize()方法是这样的&#xff1a; void resize(int newCapacity) { Entry[] oldTable table; int oldCapacity oldTable.length; if (oldCapacity MAXIMUM_CAPACITY) { threshold Integer.…
阅读更多...
零样本视频生成无压力，基于飞桨框架实现Text2Video-Zero核心代码及依赖库

零样本视频生成无压力，基于飞桨框架实现Text2Video-Zero核心代码及依赖库

项目背景 继 AI 绘画之后&#xff0c;短视频行业正迎来 AI 智能创作的新浪潮。AI 智能创作正在各个方面为创作者和用户带来新的体验和价值。AI 动漫视频、AI 瞬息宇宙、AI 视频风格化等诸多创作功能不仅为视频内容创作提供了全新灵感&#xff0c;而且大大降低了用户创作的门槛…
阅读更多...
SpringMVC原理分析 | 数据处理：ModelAndView

SpringMVC原理分析 | 数据处理：ModelAndView

&#x1f497;wei_shuo的个人主页 &#x1f4ab;wei_shuo的学习社区 &#x1f310;Hello World &#xff01; 重定向和转发 ModelAndView 设置ModelAndView对象&#xff0c;根据view的名称、视图解析器跳转到指定的页面 页面&#xff1a;{视图解析器前缀} viewName {视图解析器…
阅读更多...
git常用命令之命令集

git常用命令之命令集

15. 命令集 场景1. 构造1个文件的10个commit 命令作用for i in {1..10}; do date >> 66.txt && git add . && git commit -sm "update"; done自证 场景2. 构造10个文件 命令作用for i in {1..10}; do date >> "file_$i.log&quo…
阅读更多...
Quiz 7: Files | Python for Everybody 配套练习_解题记录

Quiz 7: Files | Python for Everybody 配套练习_解题记录

文章目录 课程简介Quiz 7: Files 单选题&#xff08;1-10&#xff09;编程题Exercise 7.2 课程简介 Python for Everybody 零基础程序设计&#xff08;Python 入门&#xff09; This course aims to teach everyone the basics of programming computers using Python. 本课程…
阅读更多...
项目——学生信息管理系统1

项目——学生信息管理系统1

目录 创建项目 1. 修改Eclipse的编码为UTF-8,具体参考给的文档 1.1 设置代码自动保存 2. 创建Java项目 分包 添加数据库驱动jar包依赖 复制数据库驱动jar包到lib目录下 添加依赖 创建登陆页面 在 org.xingyun.view 包下创建 LoginFrm 选择 WindowBuilder下的 Swing D…
阅读更多...
oracle 重复启动监听程序故障

oracle 重复启动监听程序故障

又是一起 oracle 无法连接问题&#xff0c;检查配置都是正常的。 原来是碰到一个oralce的bugl了。 还真就是这个问题&#xff0c;子进程一kill掉&#xff0c;就恢复了。
阅读更多...
微服务实战项目-学成在线-课程发布模块

微服务实战项目-学成在线-课程发布模块

学成在线-课程发布模块 1 模块需求分析 1.1 模块介绍 课程信息编辑完毕即可发布课程&#xff0c;发布课程相当于一个确认操作&#xff0c;课程发布后学习者在网站可以搜索到课程&#xff0c;然后查看课程的详细信息&#xff0c;进一步选课、支付、在线学习。 下边是课程编辑…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023