JAVA进阶--多线程、定时器、并发并行、线程的生命周期--2022年9月8日

2022/9/15 14:19:39

本文主要是介绍JAVA进阶--多线程、定时器、并发并行、线程的生命周期--2022年9月8日,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

第一节、多线程的创建

  1、线程概述

    A、什么是线程

    

 

     B、多线程是什么

    

  2、继承Thread类

    A、继承Thread类是如何实现多线程的

      继承Thread类

      重写run方法

      创建线程对象

      调用start()方法启动

    B、优缺点是什么

      优点:编码简单

      缺点:存在单继承的局限性,线程类继承Thread后,不能继承其他类,不便于扩展。

    C、为什么不直接调用run()方法,而是调用start()启动线程

      直接调用run方法会当次普通方法执行,此时相当于还是单线程执行

      只有调用start方法才是启动一个新的线程执行

    D、把主线程任务放在子线程之前会怎么样

      这样主线程一直是先跑完,相当于是一个线程的效果了

    

 1 package com.itheima.d1_create;
 2 
 3 /**
 4    目标:多线程的创建方式一:继承Thread类实现。
 5  */
 6 public class ThreadDemo1 {
 7     public static void main(String[] args) {
 8         // 3、new一个新线程对象
 9         Thread t = new MyThread();
10         // 4、调用start方法启动线程(执行的还是run方法)
11         t.start();
12 
13         for (int i = 0; i < 5; i++) {
14             System.out.println("主线程执行输出:" + i);
15         }
16 
17     }
18 }
19 
20 /**
21    1、定义一个线程类继承Thread类
22  */
23 class MyThread extends Thread{
24     /**
25        2、重写run方法,里面是定义线程以后要干啥
26      */
27     @Override
28     public void run() {
29         for (int i = 0; i < 5; i++) {
30             System.out.println("子线程执行输出:" + i);
31         }
32     }
33 }
继承thread类创建线程

  3、实现Runnable接口

    A。实现Uunnable接口是如何创建线程的

      定义一个线程任务类型MyRunnable实现Runnable接口,重写run()方法

      创建MyRunnable任务对象

      把MyRunnable任务对象交给Thread线程对象处理

      调用线程对象的start()方法启动线程

    B、这种方式的优缺点

      优点:线程任务只是实现了Runnable接口,可以继续继承和实现

      缺点:编程多一层包装对象,如果线程有执行结果是不能直接返回的

    

 1 package com.itheima.d1_create;
 2 
 3 /**
 4    目标:学会线程的创建方式二,理解它的优缺点。
 5  */
 6 public class ThreadDemo2 {
 7     public static void main(String[] args) {
 8         // 3、创建一个任务对象
 9         Runnable target = new MyRunnable();
10         // 4、把任务对象交给Thread处理
11         Thread t = new Thread(target);
12         // Thread t = new Thread(target, "1号");
13         // 5、启动线程
14         t.start();
15 
16         for (int i = 0; i < 10; i++) {
17             System.out.println("主线程执行输出:" + i);
18         }
19     }
20 }
21 
22 /**
23    1、定义一个线程任务类 实现Runnable接口
24  */
25 class MyRunnable  implements Runnable {
26     /**
27        2、重写run方法,定义线程的执行任务的
28      */
29     @Override
30     public void run() {
31         for (int i = 0; i < 10; i++) {
32             System.out.println("子线程执行输出:" + i);
33         }
34     }
35 }
实现Runnable接口

     =============================================================================================

    

 1 package com.itheima.d1_create;
 2 
 3 /**
 4    目标:学会线程的创建方式二(匿名内部类方式实现,语法形式)
 5  */
 6 public class ThreadDemo2Other {
 7     public static void main(String[] args) {
 8         Runnable target = new Runnable() {
 9             @Override
10             public void run() {
11                 for (int i = 0; i < 10; i++) {
12                     System.out.println("子线程1执行输出:" + i);
13                 }
14             }
15         };
16         Thread t = new Thread(target);
17         t.start();
18 
19         new Thread(new Runnable() {
20             @Override
21             public void run() {
22                 for (int i = 0; i < 10; i++) {
23                     System.out.println("子线程2执行输出:" + i);
24                 }
25             }
26         }).start();
27 
28         new Thread(() -> {
29                 for (int i = 0; i < 10; i++) {
30                     System.out.println("子线程3执行输出:" + i);
31             }
32         }).start();
33 
34         for (int i = 0; i < 10; i++) {
35             System.out.println("主线程执行输出:" + i);
36         }
37     }
38 }
实现Runnable接口-匿名对象类

  4、JDK5.0新增:实现Callable接口

    A、利用Callable、FutureTask接口实现的步骤

      得到任务对象

        定义类实现Callable接口,重写call方法,封装要做的事情

        用FutureTask把Callable对象封装成线程任务对象

      把线程任务对象交给Thread处理

      调用Thread的start方法启动线程,执行任务

      线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果

    

 

 

     ==============================================================================

    

 

 

     ===============================================================================================

    

 1 package com.itheima.d1_create;
 2 
 3 import java.util.concurrent.Callable;
 4 import java.util.concurrent.ExecutionException;
 5 import java.util.concurrent.FutureTask;
 6 
 7 /**
 8    目标:学会线程的创建方式三:实现Callable接口,结合FutureTask完成。
 9  */
10 public class ThreadDemo3 {
11     public static void main(String[] args) {
12         // 3、创建Callable任务对象
13         Callable<String> call = new MyCallable(100);
14         // 4、把Callable任务对象 交给 FutureTask 对象
15         //  FutureTask对象的作用1: 是Runnable的对象(实现了Runnable接口),可以交给Thread了
16         //  FutureTask对象的作用2: 可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
17         FutureTask<String> f1 = new FutureTask<>(call);
18         // 5、交给线程处理
19         Thread t1 = new Thread(f1);
20         // 6、启动线程
21         t1.start();
22 
23 
24         Callable<String> call2 = new MyCallable(200);
25         FutureTask<String> f2 = new FutureTask<>(call2);
26         Thread t2 = new Thread(f2);
27         t2.start();
28 
29         try {
30             // 如果f1任务没有执行完毕,这里的代码会等待,直到线程1跑完才提取结果。
31             String rs1 = f1.get();
32             System.out.println("第一个结果:" + rs1);
33         } catch (Exception e) {
34             e.printStackTrace();
35         }
36 
37         try {
38             // 如果f2任务没有执行完毕,这里的代码会等待,直到线程2跑完才提取结果。
39             String rs2 = f2.get();
40             System.out.println("第二个结果:" + rs2);
41         } catch (Exception e) {
42             e.printStackTrace();
43         }
44     }
45 }
46 
47 /**
48     1、定义一个任务类 实现Callable接口  应该申明线程任务执行完毕后的结果的数据类型
49  */
50 class MyCallable implements Callable<String>{
51     private int n;
52     public MyCallable(int n) {
53         this.n = n;
54     }
55 
56     /**
57        2、重写call方法(任务方法)
58      */
59     @Override
60     public String call() throws Exception {
61         int sum = 0;
62         for (int i = 1; i <= n ; i++) {
63             sum += i;
64         }
65         return "子线程执行的结果是:" + sum;
66     }
67 }
第三种线程创建方式

第二节、Thread的常用方法

  1、Thread常用API

     

  2、Thread构造器

    

 1 package com.itheima.d2_api;
 2 
 3 public class MyThread extends Thread{
 4     public MyThread() {
 5     }
 6 
 7     public MyThread(String name) {
 8         // 为当前线程对象设置名称,送给父类的有参数构造器初始化名称
 9         super(name);
10     }
11 
12     @Override
13     public void run() {
14         for (int i = 0; i < 5; i++) {
15             System.out.println( Thread.currentThread().getName() + "输出:" + i);
16         }
17     }
18 }
为线程对象设置名称
 1 package com.itheima.d2_api;
 2 /**
 3     目标:线程的API
 4  */
 5 public class ThreadDemo01 {
 6     // main方法是由主线程负责调度的
 7     public static void main(String[] args) {
 8         Thread t1 = new MyThread("1号");
 9         // t1.setName("1号");
10         t1.start();
11         System.out.println(t1.getName());
12 
13         Thread t2 = new MyThread("2号");
14         // t2.setName("2号");
15         t2.start();
16         System.out.println(t2.getName());
17 
18         // 哪个线程执行它,它就得到哪个线程对象(当前线程对象)
19         // 主线程的名称就叫main
20         Thread m = Thread.currentThread();
21         System.out.println(m.getName());
22         m.setName("最牛的线程");
23 
24         for (int i = 0; i < 5; i++) {
25             System.out.println( m.getName() + "输出:" + i);
26         }
27     }
28 }
依然是名称
 1 package com.itheima.d2_api;
 2 /**
 3     目标:线程的API
 4  */
 5 public class ThreadDemo02 {
 6     // main方法是由主线程负责调度的
 7     public static void main(String[] args) throws Exception {
 8         for (int i = 1; i <= 5; i++) {
 9             System.out.println("输出:" + i);
10             if(i == 3){
11                 // 让当前线程进入休眠状态
12                 // 段子:项目经理让我加上这行代码,如果用户愿意交钱,我就注释掉。
13                 Thread.sleep(3000);
14             }
15         }
16     }
17 }
线程休眠

第三节、线程安全

  1、线程安全问题是什么

    多个线程同时操作同一个共享资源的时候可能会出现业务安全问题,称为线程安全问题

  2、线程安全问题出现的原因

    存在多线程并发

    同时访问共享资源

    存在修改共享资源,读数据是永远不会错的,只有需要修改的时候才会出错

  3、线程安全问题案例模拟

    

 1 package com.itheima.d3_thread_safe;
 2 
 3 public class Account {
 4     private String cardId;
 5     private double money; // 账户的余额
 6 
 7     public Account(){
 8 
 9     }
10 
11     public Account(String cardId, double money) {
12         this.cardId = cardId;
13         this.money = money;
14     }
15 
16     /**
17        小明 小红
18      */
19     public void drawMoney(double money) {
20         // 0、先获取是谁来取钱,线程的名字就是人名
21         String name = Thread.currentThread().getName();
22         // 1、判断账户是否够钱
23         if(this.money >= money){
24             // 2、取钱
25             System.out.println(name + "来取钱成功,吐出:" + money);
26             // 3、更新余额
27             this.money -= money;
28             System.out.println(name + "取钱后剩余:" + this.money);
29         }else {
30             // 4、余额不足
31             System.out.println(name +"来取钱,余额不足!");
32         }
33 
34     }
35 
36     public String getCardId() {
37         return cardId;
38     }
39 
40     public void setCardId(String cardId) {
41         this.cardId = cardId;
42     }
43 
44     public double getMoney() {
45         return money;
46     }
47 
48     public void setMoney(double money) {
49         this.money = money;
50     }
51 
52 }
Account类
 1 package com.itheima.d3_thread_safe;
 2 
 3 /**
 4    取钱的线程类
 5  */
 6 public class DrawThread extends Thread {
 7     // 接收处理的账户对象
 8     private Account acc;
 9     public DrawThread(Account acc,String name){
10         super(name);
11         this.acc = acc;
12     }
13     @Override
14     public void run() {
15         // 小明 小红:取钱
16         acc.drawMoney(100000);
17     }
18 }
DrawThread
 1 package com.itheima.d3_thread_safe;
 2 
 3 /**
 4     需求:模拟取钱案例。
 5  */
 6 public class ThreadDemo {
 7     public static void main(String[] args) {
 8         // 1、定义线程类,创建一个共享的账户对象
 9         Account acc = new Account("ICBC-111", 100000);
10 
11         // 2、创建2个线程对象,代表小明和小红同时进来了。
12         new DrawThread(acc, "小明").start();
13         new DrawThread(acc, "小红").start();
14     }
15 }
ThreadDemo 启动类

第四节、线程同步

  1、同步思想概述

    A、线程同步解决安全问题的思想是什么

      加锁:让多个线程实现先后依次访问共享资源,这样就解决了安全问题

  2、方式一、同步代码块

    A、同步代码块是如何实现线程安全的

      对出现问题的核心代码使用synchronized进行加锁

      每次只能一个线程占锁进入访问

    B、同步代码块的同步锁对象有什么要求

      对于实例方法建议使用this作为锁对象

      对于静态方法建议使用字节码(类名.class)对象作为锁对象

    

 

 

     ========================================================================

    

  3、方式二、同步方法

    A、同步方法是如何保证线程安全的

      对出现问题的核心方法使用synchronized修饰

      每次只能一个线程占锁进入访问

    B、同步方法的同步锁对象的原理

      对于实例方法默认使用this作为锁对象

      对于静态方法默认使用类名.class对象作为锁对象

    C、同步代码块和同步方法的比较

      同步代码块锁的范围更小,同步方法锁的范围更大

      在书写代码上面,同步方法比同步代码块更方便一点

    

 

 

     ==========================================================================

    

  4、方式三、Lock锁

    

第五节、线程通信

  1、线程通信的三个常见方法

  

 

 

   =======================================================================

  

 1 package com.itheima.d7_thread_comunication;
 2 
 3 /**
 4    呼叫系统。
 5  */
 6 public class CallSystem {
 7     // 定义一个变量记录当前呼入进来的电话。
 8     public static int number = 0; // 最多只接听一个。
 9 
10     /* 接入电话
11      */
12     public synchronized static void call() {
13         try {
14             number++;
15             System.out.println("成功接入一个用户,等待分发~~~~");
16 
17             // 唤醒别人 : 1个
18             CallSystem.class.notify();
19             // 让当前线程对象进入等待状态。
20             CallSystem.class.wait();
21 
22         } catch (InterruptedException e) {
23             e.printStackTrace();
24         }
25     }
26 
27     /**
28        分发电话
29      */
30     public synchronized static void receive() {
31         try {
32             String name = Thread.currentThread().getName();
33             if(number == 1){
34                 System.out.println(name + "此电话已经分发给客服并接听完毕了~~~~~");
35                 number--;
36                 // 唤醒别人 : 1个
37                 CallSystem.class.notify();
38                 CallSystem.class.wait(); // 让当前线程等待
39             }else {
40                 // 唤醒别人 : 1个
41                 CallSystem.class.notify();
42                 CallSystem.class.wait(); // 让当前线程等待
43             }
44         } catch (InterruptedException e) {
45             e.printStackTrace();
46         }
47     }
48 }
线程通信案例CallSystem
 1 package com.itheima.d7_thread_comunication;
 2 
 3 public class CallThread extends Thread{
 4     @Override
 5     public void run() {
 6         // 不断的打入电话
 7         while (true){
 8             CallSystem.call();
 9         }
10     }
11 }
线程通信案例 CallThread
 1 package com.itheima.d7_thread_comunication;
 2 
 3 /**
 4    接电话线程类
 5  */
 6 public class ReceiveThread extends Thread{
 7     @Override
 8     public void run() {
 9         // 1号  2号
10         while (true){
11             CallSystem.receive();
12         }
13     }
14 }
线程通信案例 ReceiveThread
 1 package com.itheima.d7_thread_comunication;
 2 
 3 public class TestDemo {
 4     public static void main(String[] args) {
 5         // 1、生产者线程:负责不断接收打进来的电话
 6         CallThread call = new CallThread();
 7         call.start();
 8 
 9         // 2、消费者线程:客服,每个客服每次接听一个电话
10         ReceiveThread r1 = new ReceiveThread();
11         r1.start();
12     }
13 }
线程通信案例 TestDemo

第六节、线程池

  1、线程池概述

    

 

 

     ===============================================================================================

    

  2、线程池实现的API、参数说明

    A、谁代表了线程池

      ExecutorService接口

      

    B、ThreadPoolExecutor实现线程池对象的七个参数是什么意思

      使用线程池的实现类ThreadPoolExecutor

      

 

     C、线程池常见面试题

      a、临时线程什么时候创建

        新任务提交时发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程

      b、什么时候会开始拒绝任务

        核心线程和临时线程都在忙,任务队列也满了,新的任务过来的时候才会开始任务拒绝

  3、线程池处理Runnable任务

    A、线程池如何处理Runnable任务

      使用ExecutorService的方法:void execute(Runnable target)

    

 

     =====================================================================================================

    

  4、线程池处理Callable任务

    A、线程池如何处理Callable任务,并得到任务执行完后返回结果

      使用ExecutorService的方法:Future<T>submit(Callable<T>command)

 1 package com.itheima.d8_threadpool;
 2 
 3 import java.util.concurrent.Callable;
 4 
 5 /**
 6     1、定义一个任务类 实现Callable接口  应该申明线程任务执行完毕后的结果的数据类型
 7  */
 8 public class MyCallable implements Callable<String>{
 9     private int n;
10     public MyCallable(int n) {
11         this.n = n;
12     }
13 
14     /**
15        2、重写call方法(任务方法)
16      */
17     @Override
18     public String call() throws Exception {
19         int sum = 0;
20         for (int i = 1; i <= n ; i++) {
21             sum += i;
22         }
23         return Thread.currentThread().getName()
24                 + "执行 1-" + n+ "的和,结果是:" + sum;
25     }
26 }
MyCallable
 1 package com.itheima.d8_threadpool;
 2 
 3 public class MyRunnable implements Runnable{
 4     @Override
 5     public void run() {
 6         for (int i = 0; i < 5; i++) {
 7             System.out.println(Thread.currentThread().getName() + "输出了:HelloWorld ==> "  + i);
 8         }
 9         try {
10             System.out.println(Thread.currentThread().getName() + "本任务与线程绑定了,线程进入休眠了~~~");
11             Thread.sleep(10000000);
12         } catch (Exception e) {
13             e.printStackTrace();
14         }
15     }
16 }
MyRunnable
 1 package com.itheima.d8_threadpool;
 2 
 3 import java.util.concurrent.*;
 4 
 5 /**
 6     目标:自定义一个线程池对象,并测试其特性。
 7  */
 8 public class ThreadPoolDemo1 {
 9     public static void main(String[] args) {
10         // 1、创建线程池对象
11         /**
12          public ThreadPoolExecutor(int corePoolSize,
13                                  int maximumPoolSize,
14                                  long keepAliveTime,
15                                  TimeUnit unit,
16                                  BlockingQueue<Runnable> workQueue,
17                                  ThreadFactory threadFactory,
18                                  RejectedExecutionHandler handler)
19          */
20         ExecutorService pool = new ThreadPoolExecutor(3, 5 ,
21                 6, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5) , Executors.defaultThreadFactory(),
22                new ThreadPoolExecutor.AbortPolicy() );
23 
24         // 2、给任务线程池处理。
25         Runnable target = new MyRunnable();
26         pool.execute(target);
27         pool.execute(target);
28         pool.execute(target);
29 
30         pool.execute(target);
31         pool.execute(target);
32         pool.execute(target);
33         pool.execute(target);
34         pool.execute(target);
35 
36         // 创建临时线程
37         pool.execute(target);
38         pool.execute(target);
39 //        // 不创建,拒绝策略被触发!!!
40 //        pool.execute(target);
41 
42         // 关闭线程池(开发中一般不会使用)。
43         // pool.shutdownNow(); // 立即关闭,即使任务没有完成,会丢失任务的!
44         pool.shutdown(); // 会等待全部任务执行完毕之后再关闭(建议使用的)
45     }
46 }
ThreadPoolDemo1
 1 package com.itheima.d8_threadpool;
 2 
 3 import java.util.concurrent.*;
 4 
 5 /**
 6     目标:自定义一个线程池对象,并测试其特性。
 7  */
 8 public class ThreadPoolDemo2 {
 9     public static void main(String[] args) throws Exception {
10         // 1、创建线程池对象
11         /**
12          public ThreadPoolExecutor(int corePoolSize,
13                                  int maximumPoolSize,
14                                  long keepAliveTime,
15                                  TimeUnit unit,
16                                  BlockingQueue<Runnable> workQueue,
17                                  ThreadFactory threadFactory,
18                                  RejectedExecutionHandler handler)
19          */
20         ExecutorService pool = new ThreadPoolExecutor(3, 5 ,
21                 6, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5) , Executors.defaultThreadFactory(),
22                new ThreadPoolExecutor.AbortPolicy() );
23 
24         // 2、给任务线程池处理。
25         Future<String> f1 = pool.submit(new MyCallable(100));
26         Future<String> f2 = pool.submit(new MyCallable(200));
27         Future<String> f3 = pool.submit(new MyCallable(300));
28         Future<String> f4 = pool.submit(new MyCallable(400));
29         Future<String> f5 = pool.submit(new MyCallable(500));
30 
31 //        String rs = f1.get();
32 //        System.out.println(rs);
33 
34         System.out.println(f1.get());
35         System.out.println(f2.get());
36         System.out.println(f3.get());
37         System.out.println(f4.get());
38         System.out.println(f5.get());
39     }
40 }
ThreadPoolDemo2
 1 package com.itheima.d8_threadpool;
 2 
 3 import java.util.concurrent.*;
 4 
 5 /**
 6     目标:使用Executors的工具方法直接得到一个线程池对象。
 7  */
 8 public class ThreadPoolDemo3 {
 9     public static void main(String[] args) throws Exception {
10         // 1、创建固定线程数据的线程池
11         ExecutorService pool = Executors.newFixedThreadPool(3);
12 
13         pool.execute(new MyRunnable());
14         pool.execute(new MyRunnable());
15         pool.execute(new MyRunnable());
16         pool.execute(new MyRunnable()); // 已经没有多余线程了
17     }
18 }
ThreadPoolDemo3

  5、Executors工具类实现线程池

    A、Executor工具类底层是基于什么方式实现的线程池对象

      线程池ExecutorService的实现类:ThreadPoolExecutor

    B、Executor是否适合做大型互联网场景的线程池方案

      不适合

      建议使用ThreadPoolExecutor来指定线程池参数,这样可以明确线程池的运行规则,规避资源耗尽的风险

    

 

     ==========================================================================================================

    

 

     ===========================================================================================================

    

第七节、补充知识:定时器

  1、定时器是什么,它的作用是什么

    定时器是一种控制任务延时调用,或者周期调用的技术

    作用:闹钟、定时邮件发送

  2、定时器的实现方式

    方式一:Timer

    方式二:ScheduledExecutorService

  

 1 package com.itheima.d9_timer;
 2 
 3 import java.util.Date;
 4 import java.util.Timer;
 5 import java.util.TimerTask;
 6 
 7 /**
 8     目标:Timer定时器的使用和了解。
 9  */
10 public class TimerDemo1 {
11     public static void main(String[] args) {
12         // 1、创建Timer定时器
13         Timer timer = new Timer();  // 定时器本身就是一个单线程。
14         // 2、调用方法,处理定时任务
15         timer.schedule(new TimerTask() {
16             @Override
17             public void run() {
18                 System.out.println(Thread.currentThread().getName() + "执行AAA~~~" + new Date());
19 //                try {
20 //                    Thread.sleep(5000);
21 //                } catch (InterruptedException e) {
22 //                    e.printStackTrace();
23 //                }
24             }
25         }, 0, 2000);
26 
27         timer.schedule(new TimerTask() {
28             @Override
29             public void run() {
30                 System.out.println(Thread.currentThread().getName() + "执行BB~~~"+ new Date());
31                 System.out.println(10/0);
32             }
33         }, 0, 2000);
34 
35         timer.schedule(new TimerTask() {
36             @Override
37             public void run() {
38                 System.out.println(Thread.currentThread().getName() + "执行CCC~~~"+ new Date());
39             }
40         }, 0, 3000);
41     }
42 }
Timer

  

 1 package com.itheima.d9_timer;
 2 
 3 import java.util.Date;
 4 import java.util.Timer;
 5 import java.util.TimerTask;
 6 import java.util.concurrent.Executors;
 7 import java.util.concurrent.ScheduledExecutorService;
 8 import java.util.concurrent.TimeUnit;
 9 
10 /**
11     目标:Timer定时器的使用和了解。
12  */
13 public class TimerDemo2 {
14     public static void main(String[] args) {
15         // 1、创建ScheduledExecutorService线程池,做定时器
16         ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);
17 
18         // 2、开启定时任务
19         pool.scheduleAtFixedRate(new TimerTask() {
20             @Override
21             public void run() {
22                 System.out.println(Thread.currentThread().getName() + "执行输出:AAA  ==》 " + new Date());
23                 try {
24                     Thread.sleep(100000);
25                 } catch (InterruptedException e) {
26                     e.printStackTrace();
27                 }
28             }
29         }, 0, 2, TimeUnit.SECONDS);
30 
31 
32         pool.scheduleAtFixedRate(new TimerTask() {
33             @Override
34             public void run() {
35                 System.out.println(Thread.currentThread().getName() + "执行输出:BBB  ==》 " + new Date());
36                 System.out.println(10 / 0);
37             }
38         }, 0, 2, TimeUnit.SECONDS);
39 
40 
41         pool.scheduleAtFixedRate(new TimerTask() {
42             @Override
43             public void run() {
44                 System.out.println(Thread.currentThread().getName() + "执行输出:CCC  ==》 " + new Date());
45             }
46         }, 0, 2, TimeUnit.SECONDS);
47 
48     }
49 }
ScheduledExecutorService

第八节、补充知识:并发、并行

  1、简单说说并发和并行的含义

    并发:CPU分时轮询的执行线程

    并行:同一个时刻同时在执行

  

 

   =======================================================================================================

  

第九节、补充知识:线程的生命周期

  1、线程的6种状态

     

 

       ==================================================================================================

      

 



这篇关于JAVA进阶--多线程、定时器、并发并行、线程的生命周期--2022年9月8日的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程