【JavaSE】线程通信，线程池，定时器

最新推荐文章于 2022-06-23 19:16:27 发布
最新推荐文章于 2022-06-23 19:16:27 发布
阅读量583 收藏
点赞数 1
分类专栏： JavaSE 文章标签： 面试 java 经验分享 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54699828/article/details/124754510
版权

文章目录

1. 线程通信

1.1 线程通信概述

在这里插入图片描述

1.2 线程案例模拟

在这里插入图片描述
在这里插入图片描述

1.3 线程通信总结

在这里插入图片描述

2. 线程池（重点）

2.1 线程池概述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

2.2 线程池实现的API,参数说明

在这里插入图片描述

2.2.1 参数说明
  1. 指定线程池的最大的核心线程数，创建线程池需要设定
  2. 线程池支持的最大线程数：核心线程+临时线程
  3. 指定临时线程的最大存活时间
  4. 指定临时线程存活时间的单位
  5. 指定任务队列：当核心线程都处于繁忙状态时，指定任务队列的大小，当请求的任务超过任务队列最大的大小时，才会创建临时线程
  6. 指定使用哪个线程工厂进行创建线程
  7. 指定核心线程和临时线程都忙，任务队列满时，新任务来了的解决方案
    在这里插入图片描述
2.2.2 线程池常见面试题

在这里插入图片描述

2.2.3 总结

在这里插入图片描述

2.3 线程池处理Runnable任务

2.3.1 创建线程池示例

在这里插入图片描述

在创建线程池的最后一个参数我们介绍了当所有线程忙，任务队列满的时候，新任务来了怎么办

这里列举了四种拒绝策略
在这里插入图片描述

2.3.2 代码演示
  • 创建一个Runnable任务对象
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "输出了：HelloWorld ==> "  + i);
        }
        try {
            System.out.println(Thread.currentThread().getName() + "本任务与线程绑定了，线程进入休眠了~~~");
            Thread.sleep(10000000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  • 创建一个线程池, 调用线程池的execute方法执行任务
public class ThreadPoolDemo1 {
    public static void main(String[] args) {
        // 1、创建线程池对象
        /**
         public ThreadPoolExecutor(int corePoolSize,
                                 int maximumPoolSize,
                                 long keepAliveTime,
                                 TimeUnit unit,
                                 BlockingQueue<Runnable> workQueue,
                                 ThreadFactory threadFactory,
                                 RejectedExecutionHandler handler)
         */
        ExecutorService pool = new ThreadPoolExecutor(3, 5 ,
                6, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5) , Executors.defaultThreadFactory(),
               new ThreadPoolExecutor.AbortPolicy() );

        // 2、给任务线程池处理。
        Runnable target = new MyRunnable();
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);

        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);

        // 创建临时线程
        pool.execute(target);
        pool.execute(target);
//        // 不创建，拒绝策略被触发！！！
//        pool.execute(target);

        // 关闭线程池（开发中一般不会使用）。
        // pool.shutdownNow(); // 立即关闭，即使任务没有完成，会丢失任务的！
        pool.shutdown(); // 会等待全部任务执行完毕之后再关闭（建议使用的）
    }
}

创建3个任务的运行结果
在这里插入图片描述
创建8个任务的运行结果
在这里插入图片描述
创建十个线程任务的结果
在这里插入图片描述
创建十一个线程的结果
在这里插入图片描述

总结一下：

我们创建的线程池核心线程为3，最大线程为5，也就是临时线程数为2，任务队列为5，因此，当我们创建3个任务时，核心线程帮我们执行。

当我们创建8个任务时，消息队列刚好满，这时候会等待核心线程处理完毕任务再从消息队列中获取任务。

当我们创建十个任务时，总任务数超过核心线程和消息队列的总和，这时候会创建临时线程来执行任务。

当创建十一个任务时，总任务数超过核心线程+临时线程+消息队列可容纳的数量，因此会触发任务拒绝策略。

2.3.3 总结

在这里插入图片描述

2.4 线程池处理Callable任务

2.4.1 执行Callable任务方法

在这里插入图片描述

2.4.2 代码演示
  • 创建Callable任务
public class MyCallable implements Callable<String>{
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }

    /**
       2、重写call方法（任务方法）
     */
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n ; i++) {
            sum += i;
        }
        return Thread.currentThread().getName()
                + "执行 1-" + n+ "的和，结果是：" + sum;
    }
}
  • 创建线程池执行Callable任务
public class ThreadPoolDemo2 {
    public static void main(String[] args) throws Exception {
        // 1、创建线程池对象
        /**
         public ThreadPoolExecutor(int corePoolSize,
                                 int maximumPoolSize,
                                 long keepAliveTime,
                                 TimeUnit unit,
                                 BlockingQueue<Runnable> workQueue,
                                 ThreadFactory threadFactory,
                                 RejectedExecutionHandler handler)
         */
        ExecutorService pool = new ThreadPoolExecutor(3, 5 ,
                6, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5) , Executors.defaultThreadFactory(),
               new ThreadPoolExecutor.AbortPolicy() );

        // 2、给任务线程池处理。
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));
        Future<String> f5 = pool.submit(new MyCallable(500));

//        String rs = f1.get();
//        System.out.println(rs);

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
        System.out.println(f5.get());
    }
}

执行结果：这里调用get方法是因为get方法返回的是线程执行完毕后的结果
在这里插入图片描述

2.4.3 总结

在这里插入图片描述

2.5 Executors工具类实现线程池

2.5.1 常用方法

在这里插入图片描述

2.5.2 Executors工具类使用可能存在的陷阱（注意）

在这里插入图片描述
OOM（Out Of Memory） 内存溢出
在这里插入图片描述

2.5.3 代码演示
public class ThreadPoolDemo3 {
    public static void main(String[] args) throws Exception {
        // 1、创建固定线程数据的线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);

        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable()); // 已经没有多余线程了
    }
}

在这里插入图片描述

2.5.4 总结

在这里插入图片描述

3. 定时器

3.1 定时器介绍

在这里插入图片描述

3.2 Timer定时器

在这里插入图片描述

public class TimerDemo1 {
    public static void main(String[] args) {
        // 1、创建Timer定时器
        Timer timer = new Timer();  // 定时器本身就是一个单线程。
        // 2、调用方法，处理定时任务
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行AAA~~~" + new Date());
            }
        }, 0, 2000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行BB~~~"+ new Date());
                //System.out.println(10/0);
            }
        }, 0, 2000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行CCC~~~"+ new Date());
            }
        }, 0, 3000);
    }
}

在这里插入图片描述

我们将第二个任务的 System.out.println(10/0); 打开，观察执行效果
在这里插入图片描述
可以看到，程序遇到异常就直接结束了。这就是使用Timer定时器的弊端

3.3 ScheduledExecutorService定时器

在这里插入图片描述

public class TimerDemo2 {
    public static void main(String[] args) {
        // 1、创建ScheduledExecutorService线程池，做定时器
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);

        // 2、开启定时任务
        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出：AAA  ==》 " + new Date());
                try {
                    Thread.sleep(100000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, 0, 2, TimeUnit.SECONDS);


        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出：BBB  ==》 " + new Date());
                System.out.println(10 / 0);
            }
        }, 0, 2, TimeUnit.SECONDS);


        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出：CCC  ==》 " + new Date());
            }
        }, 0, 2, TimeUnit.SECONDS);

    }
}

我们直接带着异常条件进行测试
在这里插入图片描述
分析一下：线程执行完A任务后睡眠了，而线程执行完B任务后挂掉了，但是线程执行C不会受到影响。

这种方式的定时器解决了Timer定时器因任务异常挂掉而不能继续执行任务的弊端。

4. 并发，并行

4.1 什么是并发

在这里插入图片描述

4.2 什么是并行

在这里插入图片描述

4.3 总结

在这里插入图片描述

5. 线程的生命周期

5.1 线程的状态

在这里插入图片描述
在这里插入图片描述

5.2 线程的转换过程

在这里插入图片描述
在这里插入图片描述

5.3 总结

在这里插入图片描述

ぃ小男孩つ
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSE 多线程——定时器
Lv Zejiang
09-09 223
Java自我学习路线一、定时器概述二、定时器的实现方式三、Timer1. 构造方法1.1 无参构造方法1.2 有参构造方法四、TimerTask五、schdule六、scheduleAtFixedRate 一、定时器概述 间隔特定的时间，执行特定的程序 二、定时器的实现方式 使用sleep() 方法，设置睡眠时间，在某个时间点唤醒执行相关执行（相当于原始定时器，不怎么用） Java中的类库：java.util.Timer，用于Java线程里指定时间或周期运行任务，Timer是线程安全的，但不提供实时性
JavaSE——多线程
qq_46002941的博客
01-22 205
记录看视频自学多线程的一些笔记
javaSE Timer, 定时器, 任务调度
houyanhua1的专栏
07-04 347
TimerDemo.java：package com.xxx.demo; import java.util.Date; import java.util.Timer; import java.util.TimerTask; public class TimerDemo { public static void main(String[] args) { Timer timer = ne...
JAVA.SE定时器
qq_41125149的博客
04-12 276
文章目录1.定时器1.1概念1.2定时器Timer的使用 1.定时器 1.1概念 让某个线程在某个时间做指定的任务 或者让某个时间间隔之后执行 1.2定时器Timer的使用 构造方法 public Timer(); 成员方法 schedule public void schedule(TimerTask task, long delay); //在指定的时间之后执行指定的任务 public voi...
javase：定时器
m0_63834567的博客
01-06 86
import java.text.SimpleDateFormat; import java.util.Date; import java.util.Timer; import java.util.TimerTask; public class TimerTest { public static void main(String[] args) throws Exception { // 创建定时器对象 Timer timer = new Timer(); .
Java笔记(JavaSE的定时器):
weixin_46657047的博客
10-26 97
1.Timer定时器: 1)注解说明: public abstract class TimerTask extends Object implements Runnable 2)构造方法: public Timer():创建一个新的定时器,不是守护线程! 3)成员方法: public void cancel():取消定时器 public void schedule(TimerTask task,long delay):经过多少毫秒后执行一次定时任务 public void sched
Quartz定时器与定时任务知识概括
weixin_41005188的博客
09-21 3419
Quartz定时器知识概括Quartz简介Quartz简单入门Spring和Quartz集成SSMM和Quartz集成Quartz集群Quartz配置Quartz分布式Quartz总结 Quartz简介 Quartz简介： Quartz是OpenSymphony开源组织在Jobscheduling领域又一个开源项目，是完全由java开发的一个开源的任务日程管理系统，“任务进度管理器”就是一个在预先确定（被纳入日程）的时间到达时，负责执行（或者通知）其他软件组件的系统。 Quartz用一个小Java库发布文
java面试宝典书籍-JavaSE基础
qq_28400629的博客
08-08 399
知识：java面试宝典 JavaSE基础注：知识都来源于Java面试宝典书籍，此处只为学习 一、Java面向对象 Standard Edition 1. 面向对象的特性以及理解 封装：将对象进行封装，封装后可以通过调用对象的方式调用对象的属性，使一切变得有序 继承：父类、子类，继承方法 多态：方法重写(修改方法里的内容)、方法重载(方式所携带的参数不同) 、对象造...
线程，看这一篇就够啦
w_rcss的博客
07-30 470
文章目录多线程一 进程和多线程进程线程并发和并行上下文切换CAS算法协程死锁为什么要使用多线程二 使用多线程2.1继承Thread类2.2实现Runnable接口2.3实现Callable接口，callable+futureTask2.4实现Callable接口，线程池+future三 线程的状态：新建状态 new就绪状态 runnable运行状态 running阻塞状态 blocked死亡状态 ...
Java并发编程（总结最全面的面试题！！！）
q66562636的博客
06-23 1335
为什么要使用并发编程提升多核CPU的利用率：一般来说一台主机上的会有多个CPU核心，我们可以创建多个线程，理论上讲操作系统可以将多个线程分配给不同的CPU去执行，每个CPU执行一个线程，这样就提高了CPU的使用效率，如果使用单线程就只能有一个CPU核心被使用。比如当我们在网上购物时，为了提升响应速度，需要拆分，减库存，生成订单等等这些操作，就可以进行拆分利用多线程的技术完成。面对复杂业务模型，并行程序会比串行程序更适应业务需求，而并发编程更能吻合这种业务拆分 。简单来说就是：多线程应用场景并发编程有什么缺点
javase学习记录之------定时器
Striving
10-29 88
import java.util.Timer; import java.util.TimerTask; /* 定时器：可以让我们在指定的时间做某个事情，还可以重复做某件事情 依赖Timer和TimerTask这两个类 Timer:定时 public Timer() public void schedule(TimerTask task,long delay) public void schedule(TimerTask task,long delay,long period)
java的几种定时器
热门推荐
coolwind的博客
09-25 7万+
总结一下我使用过的4种类型的定时器：@Scheduled注解、quartz、new Timer().schedule、使用线程控制。 1.@Scheduled注解 @Scheduled注解是最简单的方式，只需要启用定时器，在方法上添加注解即可。 在spring配置中加入： &lt;!-- 启用注解定时器 --&gt; &lt;task:annotation-driven /&gt; ...
java实现定时任务的三种方法
zhuyucheng123的专栏
05-28 3857
本文转自： [java] view plaincopy /**   * 普通thread   * 这是最常见的，创建一个thread，然后让它在while循环里一直运行着，   * 通过sleep方法来达到定时任务的效果。这样可以快速简单的实现，代码如下：   * @author GT   *   */   public cla
JAVA：定时器的三种方法（详细注解）
平凡的人类的博客
10-14 7万+
第一种： 创建一个thread，然后让它在while循环里一直运行着，通过sleep方法来达到定时任务的效果，代码如下： public class Task1 { public static void main(String[] args) { // run in a second // 每一秒钟执行一次 final long timeInterval = 10...
java当中的定时器
weixin_30732487的博客
12-02 151
对于开发游戏项目的同胞来说，Timer 这个东西肯定不会陌生，今天对以前自己经常使用的定时进行了一番小小的总结！没有写具体实现的原理，只是列举出了其中的四种比较常见的使用方法，相对而言，所以只要按照其所列举的例子仿照即可！import java.util.Calendar;import java.util.Date;import java.util.Timer;import java.util.T...
关于java中定时器的实现 三种方式
luojian220的博客
09-25 1万+
定时任务的三种实现方式
java定时器的几种实现方式
手写代码
05-08 1万+
1 前言 在开始正题之前，先闲聊几句。有人说，计算机科学这个学科，软件方向研究到头就是数学，硬件方向研究到头就是物理，最轻松的是中间这批使用者，可以不太懂物理，不太懂数学，依旧可以使用计算机作为自己谋生的工具。这个规律具有普适应，看看“定时器”这个例子，往应用层研究，有 Quartz，Spring Schedule 等框架；往分布式研究，又有 SchedulerX，ElasticJob 等分布式任务调度；往底层实现看，又有多种定时器实现方案的原理、工作效率、数据结构可以深究…简单上手使用一个框架，并不能体
JAVA线程间通信的几种方式
hmiter的博客
03-03 6019
今天在群里面看到一个很有意思的面试题： “编写两个线程，一个线程打印1~25，另一个线程打印字母A~Z，打印顺序为12A34B56C……5152Z，要求使用线程间的通信。” 这是一道非常好的面试题，非常能彰显被面者关于多线程的功力，一下子就勾起了我的兴趣。这里抛砖引玉，给出7种想到的解法。 1. 第一种解法，包含多种小的不同实现方式，但一个共同点就是靠一个共享变量来做控制；
JavaSE多线程编程详解：创建与管理
"JavaSE多线程编程专题.pptx" 在JavaSE中，多线程编程是一项核心技能，它允许程序并发执行多个任务，...合理利用线程池，优化线程创建和销毁，以及正确处理线程间的通信和协作，能够显著提升Java程序的性能和可靠性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值