• JavaSE进阶、多线程

    目录

    一、线程的概述

     二、多线程的创建

    方式一、继承Thread类

    方式二、实现Runnable接口

    方式三、JDK5.0提供Callable、FutureTask接口

    三种方式的对比

    三、Thread的常用方法

    1、调用方法设置线程名称

    2、使用Thread构造器设置线程名称

    3、Thread类的线程休眠方法

    四、线程安全

    线程安全问题

    五、线程同步

     线程同步核心思想

    加锁方式一、同步代码块

    加锁方式二、同步方法

    加锁方式三、ReentrantLock重入锁

    六、线程通信

    七、线程池

    1、线程池的概述

    2、线程池实现的API

    线程池构造器参数

    线程池常见面试题

    3、线程池处理Runnable任务

    4、线程池处理Callable任务

    5、Executors工具类创建线程池

    八、定时器

    1、Timer定时器

     2、ScheduleExecutorService创建定时器

    九、补充知识：并发并行、生命周期

    一、线程的概述

     二、多线程的创建

    方式一、继承Thread类

    1. //使用多线程
    2.  
    3. public class ThreadDemo1 {
    4.     //默认执行的线程为主线程如main方法
    5.     public static void main(String[] args) {
    6.          //3、new一个新线程对象
    7.         Thread t = new MyThread();  //多态
    8.         //4、调用start方法，实际还是调用run方法
    9.         t.start();
    10.  
    11.         for (int i = 0; i < 5; i++) {
    12.             System.out.println("主线程" + i);
    13.         }
    14.  
    15.     }
    16. }
    17.  
    18. //1、定义一个线程类继承thread
    19. class MyThread extends Thread{
    20.     //2、重写run方法,声明线程要做什么
    21.  
    22.     @Override
    23.     public void run() {
    24.         for (int i = 0; i < 5; i++) {
    25.             System.out.println("子线程" + i);
    26.         }
    27.     }
    28. }
    29.  
    30.  
    31. //主线程与子线程同时跑
    32. 主线程0
    33. 子线程0
    34. 主线程1
    35. 子线程1
    36. 主线程2
    37. 子线程2
    38. 主线程3
    39. 子线程3
    40. 主线程4
    41. 子线程4
    1. public class Test {
    2.     public static void main(String[] args) {
    3.         Student s = new Student();
    4.         s.run();
    5.         for (int i = 0; i < 5; i++) {
    6.             System.out.println("主测试" + i);
    7.         }
    8.     }
    9. }
    10.  
    11. class Student{
    12.  
    13.     public void run(){
    14.         for (int i = 0; i < 5; i++) {
    15.             System.out.println("测试" + i);
    16.         }
    17.     }
    18. }
    19.  
    20. //不使用多线程 按顺序进行
    21. 测试0
    22. 测试1
    23. 测试2
    24. 测试3
    25. 测试4
    26. 主测试0
    27. 主测试1
    28. 主测试2
    29. 主测试3
    30. 主测试4

    继承了一个类就不能继承其他类，不利于扩展。

    为什么用start调用run方法，而不直接用run方法？

    如果直接调用run方法，则会当作普通方法来执行，按顺序执行，而不会以多线程形式进行，start方法是告诉操作系统，调用出开启新的多线程，让CPU将他作为一个单独的执行流程，以线程的方式启动，要将主线程任务放在子线程之后。

    方式二、实现Runnable接口

    1. public class ThreadDemo2 {
    2.     public static void main(String[] args) {
    3.         //学会线程创建方式二
    4.  
    5.         //2、创建任务对象，非线程对象
    6.         Runnable r = new MyRunnable();
    7.         //3、将任务对象交给Thread处理，转成线程对象
    8.         Thread t = new Thread(r);
    9.         //4、调用start方法,启动线程
    10.         t.start();
    11.  
    12.         //主线程
    13.         for (int i = 0; i < 3; i++) {
    14.             System.out.println("主线程输出" + i);
    15.         }
    16.     }
    17. }
    18.  
    19. class MyRunnable implements Runnable{
    20. //1、创建任务类继承Runable接口
    21.     @Override
    22.     public void run() {
    23.         for (int i = 0; i < 3; i++) {
    24.             System.out.println("子线程输出" + i);
    25.         }
    26.     }
    27. }
    1. public class ThreadDemo3 {
    2.     public static void main(String[] args) {
    3.         //学会线程创建方式二、匿名内部类
    4.  
    5.         //1、创建匿名任务对象
    6.         Runnable r = new Runnable() {
    7.             @Override
    8.             public void run() {
    9.                 for (int i = 0; i < 3; i++) {
    10.                     System.out.println("子线程1输出" + i);
    11.                 }
    12.             }
    13.         };
    14.         //2、将任务对象交给Thread处理，转成线程对象
    15.         Thread t = new Thread(r);
    16.         //3、调用start方法,启动线程
    17.         t.start();
    18.  
    19.         //简化写法
    20.         new Thread(new Runnable() {
    21.             @Override
    22.             public void run() {
    23.                 for (int i = 0; i < 3; i++) {
    24.                     System.out.println("子线程2输出" + i);
    25.                 }
    26.             }
    27.         }).start();
    28.         //再简化
    29.         new Thread(() -> {
    30.                 for (int i = 0; i < 3; i++) {
    31.                     System.out.println("子线程3输出" + i);
    32.                 }
    33.         }).start();
    34.  
    35.  
    36.  
    37.         //主线程
    38.         for (int i = 0; i < 3; i++) {
    39.             System.out.println("主线程1输出" + i);
    40.         }
    41.     }
    42. }

    方式三、JDK5.0提供Callable、FutureTask接口

    1. public class ThreadDemo4 {
    2.     public static void main(String[] args) {
    3.         //2、创建Callable任务对象
    4.         Callable call = new MyCallable(100);
    5.  
    6.         //3、将Callable任务对象 交给 FutureTask对象
    7.         // FutureTask对象的作用1：FutureTask是Runnable的对象(实现了Runnable接口)，可以交给Thread
    8.         // FutureTask对象的作用2：可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
    9.         FutureTask f = new FutureTask<>(call); //将call转成了Runnable的对象
    10.  
    11.         //4、交给线程处理
    12.         Thread t = new Thread(f);
    13.  
    14.         //5、启动线程
    15.         t.start();
    16.  
    17.         //6、获取线程执行的结果
    18.         try {
    19.             //如果直接用callable对象调用call方法时，call方法可能没执行完就输出了
    20.             //使用get方法一旦发现线程没有执行完他就会让出cpu 暂停执行 直到线程执行完才继续执行
    21.             String s = f.get();
    22.             System.out.println("线程1的结果：" + s);
    23.         } catch (Exception e) {
    24.             e.printStackTrace();
    25.         }
    26.  
    27.  
    28.         //线程2
    29.         Callable call2 = new MyCallable(200);
    30.         FutureTask f2 = new FutureTask<>(call2);
    31.         Thread t2 = new Thread(f2);
    32.         t2.start();
    33.         try {
    34.             String s2 = f2.get();
    35.             System.out.println("线程2的结果：" + s2);
    36.         } catch (Exception e) {
    37.             e.printStackTrace();
    38.         }
    39.  
    40.  
    41.     }
    42. }
    43.  
    44. //1、创建任务类继承Callable接口 重写call方法
    45. class MyCallable implements Callable{
    46.  
    47.     private int n;
    48.  
    49.     public MyCallable() {
    50.     }
    51.  
    52.     public MyCallable(int n) {
    53.         this.n = n;
    54.     }
    55.  
    56.     @Override
    57.     public String call() throws Exception {
    58.         int sum = 0;
    59.         for (int i = 0; i < n; i++) {
    60.             sum += n;
    61.         }
    62.         return "子线程执行的结果：" + sum;
    63.     }
    64. }

    三种方式的对比

    三、Thread的常用方法

    1、调用方法设置线程名称

    1. public class ThreadAPIDemo {
    2.     public static void main(String[] args) {
    3.         Thread t = new MyThread();
    4.         //设置线程的名字
    5.         t.setName("1号");
    6.         t.start();
    7.  
    8.         Thread t2 = new MyThread();
    9.         t2.setName("2号");
    10.         t2.start();
    11.  
    12.         //获取当前执行的线程对象
    13.         //哪个线程执行它，它就得到哪个线程对象
    14.         //主线程的名称就叫main
    15.         Thread m = Thread.currentThread();
    16.         for (int i = 0; i < 5; i++) {
    17.             System.out.println("main线程输出" + i);
    18.         }
    19.     }
    20. }

    2、使用Thread构造器设置线程名称

    1. public class ThreadAPIDemo2 {
    2.     public static void main(String[] args) {
    3.         //直接通过父类构造器创建线程名
    4.         Thread t1 = new Thread("1号");
    5.         t1.start();
    6.     }
    7. }
    8.  
    9. //MyThread继承Thread继承父类构造器
    10. public class MyThread extends Thread{
    11.  
    12.     public MyThread() {
    13.     }
    14.     
    15.     //继承父类构造器
    16.     public MyThread(String name) {
    17.         super(name);
    18.     }
    19.  
    20.     @Override
    21.     public void run() {
    22.         for (int i = 0; i < 5; i++) {
    23.             System.out.println(Thread.currentThread().getName() + "线程输出：" + i);
    24.         }
    25.     }
    26. }

    3、Thread类的线程休眠方法

    1. public static void main(String[] args) throws InterruptedException {
    2.         for (int i = 1; i < 5; i++) {
    3.             System.out.println("输出:" + i);
    4.  
    5.             if (i == 3){
    6.                 //如果i == 3 休眠3秒再执行
    7.                 Thread.sleep(3000);
    8.             }
    9.         }
    10.         
    11.     }

    四、线程安全

    线程安全问题

    两人同时取钱，会使得账户余额变为-10万导致银行亏了10万

    1. public class RemoveMoney {
    2.     public static void main(String[] args) {
    3.         //新建 账户
    4.         Account a = new Account("共享账户",10);
    5.  
    6.         //两个线程接同一个账户
    7.         //小红线程
    8.         new User("小红",a).start();
    9.  
    10.         //小明线程
    11.         new User("小明",a).start();
    12.  
    13.     }
    14. }
    15.  
    16. //线程用户类
    17. public class User extends Thread{
    18.     //关联账户类对象
    19.     private Account acc;
    20.  
    21.     public User(String name, Account acc) {
    22.         super(name);
    23.         this.acc = acc;
    24.     }
    25.  
    26.     public Account getAcc() {
    27.         return acc;
    28.     }
    29.  
    30.     public void setAcc(Account acc) {
    31.         this.acc = acc;
    32.     }
    33.  
    34.     @Override
    35.     public void run() {
    36.         acc.drawMonry(10);
    37.     }
    38. }
    39.  
    40. //账户类
    41. public class Account {
    42.     private String accountName;
    43.     private double money;
    44.  
    45.     public Account() {
    46.     }
    47.  
    48.     public Account(String accountName, double money) {
    49.         this.accountName = accountName;
    50.         this.money = money;
    51.     }
    52.  
    53.     ...
    54.  
    55.     /**
    56.      * 用户取钱
    57.      * @param i
    58.      */
    59.     public void drawMonry(double i) {
    60.         //判断是哪一个线程执行
    61.         String userName = Thread.currentThread().getName();
    62.  
    63.         //判断账户余额是否充足
    64.         if (i <= this.money){
    65.             System.out.println(userName + "来取钱成功，吐出：" + i);
    66.             //更新余额
    67.             this.money -= i;
    68.             System.out.println(userName + "来取钱剩余：" + this.money);
    69.         }else {
    70.             System.out.println(userName + "取钱，余额不足！");
    71.         }
    72.     }
    73. }

    五、线程同步

    比如银行取钱，两个用户可以同时访问账户，但是到了取钱业务时开始排队，有先后次序。

     线程同步核心思想

    加锁方式一、同步代码块

    1. public class Account {
    2.     private String accountName;
    3.     private double money;
    4.  
    5.    .
    6.    .
    7.    .
    8.  
    9.     /**
    10.      * 用户取钱
    11.      * @param i
    12.      */
    13.     public void drawMonry(double i) {
    14.         //判断是哪一个线程执行
    15.         String userName = Thread.currentThread().getName();
    16.         //取钱业务进行加锁，同步代码块
    17.         //默认锁对象
    18.         synchronized ("heima") {
    19.             //判断账户余额是否充足
    20.             if (i <= this.money){
    21.                 System.out.println(userName + "来取钱成功，吐出：" + i);
    22.                 //更新余额
    23.                 this.money -= i;
    24.                 System.out.println(userName + "来取钱剩余：" + this.money);
    25.             }else {
    26.                 System.out.println(userName + "取钱，余额不足！");
    27.             }
    28.         }
    29.     }
    30. }

     两个线程同步进行到此业务时，其中一个线程抢到锁则进入执行，同时将此业务暂时锁住，后来的线程只能等待先抢到锁的线程执行完毕，才能进入继续执行。

    问题引入：锁对象用任意唯一的对象好不好呢？(任意对象但类型唯一)

    因为这个锁是定义在账户类中，所有的账户类都共用同一个锁，当不同的线程对象使用不同的账户类时，他们所使用的锁是同一个，因此，线程A操作自己的账户A，线程B操作自己的账户B，当这两个线程同时运行，A操作A账户时，进行加锁，然而锁只有一个，所以B要操作自己的账户B 就必须等待A操作完，因此会影响其他无关线程的执行。

    1.  //对每个账户对象都设了一把独有的锁
    2. public void drawMonry(double i) {
    3.             //判断是哪一个线程执行
    4.             String userName = Thread.currentThread().getName();
    5.  
    6.             //this 表示当前账户对象，对于不同账户对象会使用不同的锁
    7.             synchronized (this) {
    8.                 //判断账户余额是否充足
    9.                 if (i <= this.money){
    10.                     System.out.println(userName + "来取钱成功，吐出：" + i);
    11.                     //更新余额
    12.                     this.money -= i;
    13.                     System.out.println(userName + "来取钱剩余：" + this.money);
    14.                 }else {
    15.                     System.out.println(userName + "取钱，余额不足！");
    16.                 }
    17.             }
    18.     }
    19.  
    20.  
    21.  
    22. //对静态方法加锁
    23.     //类名.class
    24.     public static void run(){
    25.         synchronized (Account.class){
    26.  
    27.         }
    28.     }

    加锁方式二、同步方法

    1. //加修饰符对方法加锁
    2.     public synchronized void drawMonry(double i) {
    3.             //判断是哪一个线程执行
    4.             String userName = Thread.currentThread().getName();
    5.  
    6.             //this 表示当前账户对象，对于不同账户对象会使用不同的锁
    7.  
    8.                 //判断账户余额是否充足
    9.                 if (i <= this.money){
    10.                     System.out.println(userName + "来取钱成功，吐出：" + i);
    11.                     //更新余额
    12.                     this.money -= i;
    13.                     System.out.println(userName + "来取钱剩余：" + this.money);
    14.                 }else {
    15.                     System.out.println(userName + "取钱，余额不足！");
    16.                 }
    17.  
    18.     }

     

    但是同步代码块的可读性差，同步方法更容易看出

    加锁方式三、ReentrantLock重入锁

    1. public class Account {
    2.     private String accountName;
    3.     private double money;
    4.     //对每个创建的账户类独有一个锁，并且锁唯一，不可被修改
    5.     private final ReentrantLock lock = new ReentrantLock();
    6. .
    7. .
    8. .
    9.  
    10.  public void drawMonry(double i) {
    11.         //判断是哪一个线程执行
    12.         String userName = Thread.currentThread().getName();
    13.  
    14.         //上锁
    15.         lock.lock();
    16.         //判断账户余额是否充足
    17.         try {
    18.             if (i <= this.money) {
    19.                 System.out.println(userName + "来取钱成功，吐出：" + i);
    20.                 //更新余额
    21.                 this.money -= i;
    22.                 System.out.println(userName + "来取钱剩余：" + this.money);
    23.             } else {
    24.                 System.out.println(userName + "取钱，余额不足！");
    25.             }
    26.         } catch (Exception e) {
    27.             e.printStackTrace();
    28.         } finally {
    29.             //放在finally中使解锁一定执行
    30.             //解锁
    31.             lock.unlock();
    32.         }
    33.  
    34.     }

    六、线程通信

    1. public static void main(String[] args) {
    2.         //新建账户对象
    3.         Account acc = new Account("CCC-233",0);
    4.  
    5.         //五个人用的同一把锁，锁可以跨方法
    6.         //创建两个取钱线程代表小红、小明
    7.         new UserThread("小红",acc).start();
    8.         new UserThread("小明",acc).start();
    9.  
    10.         //创建三个存钱线程表示三个爸爸
    11.         new DepositThread("岳父",acc).start();
    12.         new DepositThread("干爹",acc).start();
    13.         new DepositThread("亲爹",acc).start();
    14.  
    15.  
    16.     }
    1.  
    2. public class Account {
    3.     private String accountName;
    4.     private double money;
    5.     //每个账户都有一个自己的锁，不能被更改
    6.     private final ReentrantLock lock = new ReentrantLock();
    7.  
    8.     public Account() {
    9.     }
    10.  
    11. .
    12. .
    13. .
    14.     /**
    15.      * 取钱
    16.      * @param money
    17.      */
    18.     public synchronized void drawMoney(double money) {
    19.         //实例方法中this代表锁对象
    20.         try {
    21.             //取钱
    22.             //获取到当前线程
    23.             String name = Thread.currentThread().getName();
    24.  
    25.             //判断取钱是否大于账户
    26.             if (this.money >= money) {
    27.                 this.money -= money;
    28.                 System.out.println(name + "取钱" + money + "成功！账户余额：" + this.money);
    29.                 //取完钱，没钱了
    30.                 //先将其他进程唤醒自己在进入等待
    31.                 //用当前进程唤醒所有进程
    32.                 this.notifyAll();
    33.                 //让当前进程进入等待
    34.                 this.wait();
    35.             } else {
    36.                 //当前线程进入发现余额不足则唤醒其他线程，自己等待
    37.                 //用当前进程唤醒所有进程
    38.                 this.notifyAll();
    39.                 //让当前进程进入等待
    40.                 this.wait();
    41.             }
    42.         } catch (InterruptedException e) {
    43.             e.printStackTrace();
    44.         }
    45.  
    46.  
    47.     }
    48.  
    49.     /**
    50.      * 存钱
    51.      * @param money
    52.      */
    53.     public synchronized void depositMoney(double money) {
    54.         try {
    55.             //存钱
    56.             //获取到当前线程
    57.             String name = Thread.currentThread().getName();
    58.  
    59.             //判断取钱是否大于账户
    60.             if (this.money == 0) {
    61.                 this.money += money;
    62.                 System.out.println(name + "存钱成功！账户余额：" + this.money);
    63.                 //用当前进程唤醒所有进程
    64.                 this.notifyAll();
    65.                 //让当前进程进入等待
    66.                 this.wait();
    67.             } else {
    68.                 //还有钱不用存
    69.                 //用当前进程唤醒所有进程
    70.                 this.notifyAll();
    71.                 //让当前进程进入等待
    72.                 this.wait();
    73.             }
    74.         } catch (InterruptedException e) {
    75.             e.printStackTrace();
    76.         }
    77.     }
    78. }

    七、线程池

    1、线程池的概述

     

     假设线程池控制的最多只有三个长久存在的线程，在进入的新任务就不会创建新的线程，会等前三个线程执行完成后再来处理新线程，使线程可以重复利用，避免资源耗尽的风险，并且节约系统内存，因为如果进入一个任务就创建一个线程，线程是占用内存的，当任务过多会挤爆系统。

    2、线程池实现的API

    线程池构造器参数

     任务队列表示饭店门口的椅子，并不是实际工作的椅子，也就是允许等待的线程数量

    线程池常见面试题

    •  临时线程什么时候创建？

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

    • 什么时候会开始拒绝任务？

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

    3、线程池处理Runnable任务

     CallerRunsPolicy,由主线程负责处理，就是绕过员工交给老板处理

    1. //Runnable任务对象
    2. public class MyRunnable implements Runnable{
    3.     @Override
    4.     public void run() {
    5.         for (int i = 0; i < 5; i++) {
    6.             System.out.println(Thread.currentThread().getName() + "输出：Hello world" + "=>" + i);
    7.  
    8.         } try {
    9.             System.out.println(Thread.currentThread().getName() + "本任务与线程绑定了，线程进入休眠");
    10.             Thread.sleep(10000);
    11.         } catch (InterruptedException e) {
    12.             e.printStackTrace();
    13.         }
    14.     }
    15. }
    16.  
    17.  
    18.  
    19. public class ThreadPoolDemo {
    20.     public static void main(String[] args) {
    21.         //1、创建线程池对象
    22.         ExecutorService pool = new ThreadPoolExecutor(3,5,6, TimeUnit.SECONDS,
    23.                                                         new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
    24.                                                         new ThreadPoolExecutor.AbortPolicy());
    25.  
    26.         //2、创建任务对象给线程池处理
    27.         Runnable target = new MyRunnable();
    28.         //三个正式工处理任务
    29.         pool.execute(target);
    30.         pool.execute(target);
    31.         pool.execute(target);
    32.         //又来五个任务在门口等待，设置的任务队列最大为5
    33.         pool.execute(target);
    34.         pool.execute(target);
    35.         pool.execute(target);
    36.         pool.execute(target);
    37.         pool.execute(target);
    38.         //门口椅子坐不下了，开始请临时工
    39.         //开始创建临时线程
    40.         pool.execute(target);
    41.         pool.execute(target);
    42.         //人满了，拒绝营业
    43.         //pool.execute(target);
    44.  
    45.         //关闭线程池(开发中一般不会使用)
    46.         pool.shutdownNow();  //立即关闭，即使任务没有完成，会丢失任务
    47.         pool.shutdown();  //任务跑完才关闭
    48.  
    49.  
    50.  
    51.     }
    52. }

    4、线程池处理Callable任务

    1. //Callable任务对象
    2. public class MyCallable implements Callable {
    3.     public int n;
    4.  
    5.     public MyCallable() {
    6.     }
    7.  
    8.     public MyCallable(int n) {
    9.         this.n = n;
    10.     }
    11.  
    12.     @Override
    13.     public String call() throws Exception {
    14.         int sum = 0;
    15.         for (int i = 0; i < n; i++) {
    16.             sum += i;
    17.         }
    18.         return Thread.currentThread().getName() + "执行1-" + n +  "的和，输出结果为:" + sum;
    19.     }
    20. }
    21.  
    22.  
    23.  
    24.  
    25.  
    26. public class ThreadPoolDemo2 {
    27.     public static void main(String[] args) throws Exception {
    28.         //1、创建线程池对象
    29.         ExecutorService pool = new ThreadPoolExecutor(3,5,6, TimeUnit.SECONDS,
    30.                                                         new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
    31.                                                         new ThreadPoolExecutor.AbortPolicy());
    32.  
    33.         //2、创建任务对象给线程池处理
    34.         /*Callable call = new MyCallable(100);
    35.         pool.submit(call);*/
    36.         //submit可以接Future对象，接返回值
    37.         //三个线程可以执行完成
    38.         Future f1 = pool.submit(new MyCallable(100));
    39.         Future f2 = pool.submit(new MyCallable(200));
    40.         Future f3 = pool.submit(new MyCallable(300));
    41.         //任务队列
    42.         Future f4 = pool.submit(new MyCallable(400));
    43.         Future f5 = pool.submit(new MyCallable(500));
    44.         Future f6 = pool.submit(new MyCallable(600));
    45.         Future f7 = pool.submit(new MyCallable(600));
    46.         Future f8 = pool.submit(new MyCallable(600));
    47.         //创建临时线程
    48.         Future f9 = pool.submit(new MyCallable(600));
    49.         //String s1 = f1.get();
    50.         //取结果会等待任务执行完
    51.         System.out.println(f1.get());
    52.         System.out.println(f2.get());
    53.         System.out.println(f3.get());
    54.         System.out.println(f4.get());
    55.         System.out.println(f5.get());
    56.         System.out.println(f6.get());
    57.         System.out.println(f7.get());
    58.         System.out.println(f8.get());
    59.         System.out.println(f9.get());
    60.     }
    61. }

    5、Executors工具类创建线程池

    1. //底层源码    
    2. public static ExecutorService newFixedThreadPool(int nThreads) {
    3.     //创建指定正式工的方法中不会创建临时工
    4.     //因为正式工一旦挂了立马就会有新的线程补上来，相当于不死线程，没有空闲时间
    5.         return new ThreadPoolExecutor(nThreads, nThreads,
    6.                                       0L, TimeUnit.MILLISECONDS,
    7.                                       new LinkedBlockingQueue());
    8.     }
    1. public class ThreadExecutors {
    2.     public static void main(String[] args) {
    3.         //使用Executors工具类创建线程池
    4.         ExecutorService pool = Executors.newFixedThreadPool(3);
    5.  
    6.         pool.execute(new MyRunnable());
    7.         pool.execute(new MyRunnable());
    8.         pool.execute(new MyRunnable());
    9.         //线程池中只有三个线程，没有多余的线程处理，等前三个任务执行完再来执行
    10.         //进入等待队列
    11.         pool.execute(new MyRunnable());
    12.     }
    13. }

    八、定时器

    1、Timer定时器

    1. public class TimerDemo1 {
    2.     public static void main(String[] args) {
    3.         //Timer定时器创建和使用
    4.         //单线程任务
    5.         Timer timer = new Timer();
    6.         //调用方法，创建定时器
    7.         //3秒之后开始执行，每隔两秒再执行一次。
    8.         timer.schedule(new TimerTask() {
    9.             @Override
    10.             public void run() {
    11.                 System.out.println(Thread.currentThread().getName() + "执行了一次");
    12.             }
    13.         },3000,2000);
    14.     }
    15. }

     2、ScheduleExecutorService创建定时器

    1. public class ScheduleExecutorSerciceDemo1 {
    2.     public static void main(String[] args) {
    3.         //创建ScheduleExecutorService线程池做定时器
    4.         ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);
    5.  
    6.         //开启定时任务
    7.         //TimerTask实现了Runnable接口
    8.         pool.scheduleAtFixedRate(new TimerTask() {
    9.             @Override
    10.             public void run() {
    11.                 System.out.println(Thread.currentThread().getName() + "执行了--AAA");
    12.             }
    13.         },2,3, TimeUnit.SECONDS);
    14.     }
    15. }

    九、补充知识：并发并行、生命周期

     并发：一个CPU对多个进程服务，一次只服务一个进程，但是速度特别快，使得每个进程都被服务。

    并行 ：CPU多个线程同时执行，并且每个线程可以服务多个进程，所有并行与并发同时进行。

    生命周期

     

    sleep状态的线程是不需要抢锁 ，一旦时间到会直接变成可运行的进程，因为它休眠之后不会将锁释放，休眠结束直接运行。

    wait状态，一旦进入就会将锁释放给别人，等待结束后得到锁再继续运行。

     

     

  • 相关阅读:
    【数学建模】Topsis法python代码
    Android本地数据存储（SP、SQLite、Room）
    Kafka从入门到精通02
    流程梳理有什么价值？如何建立高效的流程管理体系？
    Pandas 基础入门（一）
    TCP/IP协议详解
    电脑重装系统之后设置
    Vue Router的介绍
    全球创新创业数据国内版
    IMX6ULL移植篇-编译单个指定的设备树文件
  • 原文地址：https://blog.csdn.net/m0_56044262/article/details/125833043