✨个人主页：bit me👇
✨当前专栏：Java EE初阶👇
✨每日一语：种一棵树最好的时间是十年前，其次是现在。

目 录

• ⌚️一. 定时器
• • 📄1. 定时器是什么
  • 📃2. 标准库中的定时器
  • 📑3. 实现定时器
• ⏰二. 线程池
• • 📕1. 标准库中的线程池
  • 📘2. 实现线程池：

⌚️一. 定时器

---

📄1. 定时器是什么

定时器也是软件开发中的一个重要组件. 类似于一个 “闹钟”. 达到一个设定的时间之后, 就执行某个指定好的代码。

定时器是一种实际开发中非常常用的组件，在标准库中也有也有
 
比如网络通信中, 如果对方 500ms 内没有返回数据, 则断开连接尝试重连.
比如一个 Map, 希望里面的某个 key 在 3s 之后过期(自动删除).
类似于这样的场景就需要用到定时器.

---

📃2. 标准库中的定时器

• 标准库中提供了一个 Timer 类. Timer 类的核心方法为 schedule .
• schedule 包含两个参数. 第一个参数指定即将要执行的任务代码, 第二个参数指定多长时间之后执行 (单位为毫秒).

public class Demo22 {
    public static void main(String[] args) throws InterruptedException {
        // java.util 里的一个组件
        Timer timer = new Timer();
        //schedule 这个方法的效果是 "安排一个任务"
        //不是立刻执行，而是 3000 ms 之后再执行
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("这是一个要执行的任务：");
            }
        },3000);

        while (true){
            System.out.println("main");
            Thread.sleep(1000);
        }
    }
}

注意：

• 程序没有结束是因为：实现定时器，背后涉及到多线程，Timer 里面有线程，这个线程的运行阻止了进程的退出！
• sleep 和定时器的区别：使用 sleep 是把当前线程给阻塞了，sleep 的时间里，啥也做不了，只能等待，但是使用定时器，之前的线程该干什么干什么。

---

📑3. 实现定时器

• 一个带优先级的阻塞队列

为啥要带优先级呢?
 
因为阻塞队列中的任务都有各自的执行时刻 (delay). 最先执行的任务一定是 delay 最小的. 使用带优先级的队列就可以高效的把这个 delay 最小的任务找出来.

• 队列中的每个元素是一个 MyTask 对象.
• MyTask 中带有一个时间属性, 队首元素就是即将执行的任务
• 同时有一个线程一直扫描队首元素, 看队首元素是否需要执行

1. MyTimer 类提供的核心接口为 schedule, 用于注册一个任务, 并指定这个任务多长时间后执行.

class MyTimer {
    public void schedule(Runnable command, long after) {
 		// TODO
    }
}

2. MyTask 类用于描述一个任务(作为 MyTimer 的内部类). 里面包含一个 Runnable 对象和一个 time(毫秒时间戳)(这个对象需要放到 优先队列 中. 因此需要实现 Comparable 接口)

class MyTask implements Comparable<MyTask> {
    private Runnable command;
    private long time;
    public MyTask(Runnable command,long after){
        this.command = command;
        this.time = System.currentTimeMillis() + after;
    }
    
    public void run(){
        command.run();
    }

    public long getTime(){
        return time;
    }

    public int compareTo(MyTask o){
        return (int) (this.time - o.time);
    }
}

• System.currentTimeMillis() + after;是一个绝对的时间戳，不是 "多长时间之后能执行"
• 重写 compareTo 方法要强制类型转换

3. MyTimer 实例中, 通过 PriorityBlockingQueue 来组织若干个 MyTask 对象.
   通过 schedule 来往队列中插入一个个 MyTask 对象.

class MyTimer {
	private Object locker = new Object();
    // 核心结构
    private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue();
    
    public void schedule(Runnable command, long after) {
        	MyTask myTask = new MyTask(command,after);
        	queue.put(task);
        	
			synchronized (locker) {
            queue.put(myTask);
            locker.notify();
        }
   }    
}

• 使用优先级队列来保存若干个任务，这个队列，会被多个线程同时访问

1. schedule 可能是在多线程中被调用，每次调用都要往队列里添加元素
2. 内部还需要有专门的线程来执行队列里的任务

4. MyTimer 类中存在一个线程, 一直不停的扫描队首元素, 看看是否能执行这个任务.(“能执行” 指的是该任务设定的时间已经到达了)

class Timer {
 // ... 前面的代码不变
	public MyTimer(){
        //在这里启动一个线程
        Thread t = new Thread(()->{
           while (true){
               //循环过程中，就不断尝试从队列中获取到队首元素
               //判定队首元素当前的时间是否就绪，如果就绪了就执行，不就绪就不执行
               try {
                   synchronized (locker) {
                       MyTask myTask = queue.take();
                       long curTime = System.currentTimeMillis();
                       if (myTask.getTime() > curTime) {
                           //时间还没到，赛回到队列中
                           queue.put(myTask);
                           locker.wait(myTask.getTime() - curTime);
                       } else {
                           //时间到了，直接执行任务
                           myTask.run();
                       }
                   }
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        t.start();
    }
}

• MyTask myTask = queue.take(); 如果队列为空，就在这块阻塞；如果队列不为空：1.取出任务 -> 2.比较时间 -> 3.如果时间未到，插入任务回队列；紧接着继续执行上述操作。
• 在短时间内产生大量循环，CPU 空转，没有实质性的执行任务，相当于 "忙等"，因此在此处需要让线程休眠直到任务执行，如果此处用 sleep 来，是行不通的，sleep 休眠的时候无法打断，而 wait 也可以休眠线程而且还能用 notify 来唤醒。
• 防范 put 和 wait 之间进行的时候出现新插入的元素要比最早的任务还早，就需要用锁把整体锁住一次执行完毕，就能有效避免出现问题。

附上总的实现代码

import java.sql.Time;
import java.util.PriorityQueue;
import java.util.concurrent.PriorityBlockingQueue;

//通过这个类来描述一个任务
class MyTask implements Comparable<MyTask> {
    //任务要干嘛
    private Runnable command;
    //任务啥时候干
    private long time;

    public MyTask(Runnable command,long after){
        this.command = command;
        //此处记录的时间是一个绝对的时间戳，不是 "多长时间之后能执行"
        this.time = System.currentTimeMillis() + after;
    }

    //执行任务的方法，直接在内部调用 Runnable 的 run 即可
    public void run(){
        command.run();
    }

    public long getTime(){
        return time;
    }

    public int compareTo(MyTask o){
        //希望时间小的在前面，时间大的在后面
        //谁减谁才能达到时间小的在前面，不用刻意背
        return (int) (this.time - o.time);
    }
}

//自己创建的定时器类
class MyTimer{
    //这是用来阻塞等待的锁对象
    private Object locker = new Object();

    //使用优先级队列来保存若干个任务
    private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();

    //command 要执行的任务是啥
    //after 多长时间之后来执行这个任务
    public void schedule(Runnable command, long after){
        MyTask myTask = new MyTask(command,after);
        queue.put(myTask);

        synchronized (locker) {
            queue.put(myTask);
            locker.notify();
        }
    }

    public MyTimer(){
        //在这里启动一个线程
        Thread t = new Thread(()->{
           while (true){
               //循环过程中，就不断尝试从队列中获取到队首元素
               //判定队首元素当前的时间是否就绪，如果就绪了就执行，不就绪就不执行
               try {
                   synchronized (locker) {
                       MyTask myTask = queue.take();
                       long curTime = System.currentTimeMillis();
                       if (myTask.getTime() > curTime) {
                           //时间还没到，赛回到队列中
                           queue.put(myTask);
                           locker.wait(myTask.getTime() - curTime);
                       } else {
                           //时间到了，直接执行任务
                           myTask.run();
                       }
                   }
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        t.start();
    }
}


public class Demo23 {
    public static void main(String[] args) {
        MyTimer myTimer = new MyTimer();

        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("3333");
            }
        },6000);
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("2222");
            }
        },4000);
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("1111");
            }
        },2000);
    }
}

---

⏰二. 线程池

由于进程太重量，创建和销毁成本都比较高(需要申请释放资源)，线程就是针对上述问题进行的优化(共用同一组系统资源)，虽然如此，但是在频繁的创建和释放的情况下，线程也扛不住，于是进一步的优化出现了。

• 线程池
• 协程(纤程)，轻量级线程

线程池解决问题的思路，就是把线程创建好了之后，放到池子里，需要使用线程，就直接从池子里取，而不是通过系统来创建，当线程用完了，也是还到池子里，而不是通过系统来销毁。

为什么把线程放到池子里就要比从系统这里创建线程来的快呢？
 
从池子里取，纯用户态操作。通过系统来创建，涉及到内核态操作。

---

📕1. 标准库中的线程池

ExecutorService threadPool = Executors.newFixedThreadPool(10);

• ExecutorService 执行器，执行 Service 服务
• Fixed 表示 “固定”
• Executors 是一个类，newFixedThreadPool 是它的静态方法，借助静态方法，来创建实例，像这样的方法，称为 “工厂方法”，对应的设计模式，就叫做 “工厂模式”（由于构造方法的限制是要求名字和类名一样，实现重载又要求参数类型和个数不一样，所以此时只能通过工厂模式来实现类名不一样，参数类型和个数完全一样）

• 使用 Executors.newFixedThreadPool(10) 能创建出固定包含 10 个线程的线程池.
• 返回值类型为 ExecutorService
• 通过 ExecutorService.submit 可以注册一个任务到线程池中.

public class Demo24 {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(10);//固定线程池里的线程数量
        //Executors.newCachedThreadPool();//逐渐增加的线程池里的线程数量

        //把任务加载到线程池，用线程池里的线程完成任务
        for (int i = 0; i < 100; i++) {
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello");
                }
            });
        }

    }
}

Executors 创建线程池的几种方式：

• newFixedThreadPool: 创建固定线程数的线程池
• newCachedThreadPool: 创建线程数目动态增长的线程池.
• newSingleThreadExecutor: 创建只包含单个线程的线程池.
• newScheduledThreadPool: 设定 延迟时间后执行命令，或者定期执行命令. 是进阶版的 Timer.

Executors 本质上是 ThreadPoolExecutor 类的封装.

ThreadPoolExecutor 提供了更多的可选参数, 可以进一步细化线程池行为的设定. (后面详解)

---

📘2. 实现线程池：

• 核心操作为 submit, 将任务加入线程池中
• 使用类描述一个工作线程. 使用 Runnable 描述一个任务.
• 使用一个 BlockingQueue 组织所有的任务
• 每个线程要做的事情: 不停的从 BlockingQueue 中取任务并执行.

class MyThreadPool {
    //这个队列就是 "任务队列" 把当前线程池要完成的任务都放到这个队列中
    //再由线程池内部的工作线程负责完成他们
    private BlockingDeque<Runnable> queue = new LinkedBlockingDeque<>();

    //核心方法：往线程池里插入任务
    public void submit(Runnable runnable){
        try {
            queue.put(runnable);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //设定线程池里有几个线程
    public MyThreadPool(int n){
        //构造方法中，就需要创建一些线程，让这些线程负责完成上述执行任务的过程
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(()->{
               while (!Thread.currentThread().isInterrupted()){//1.判断标志类  2.判断线程有没有中断，中断了就不继续走
                   try {
                       Runnable runnable = queue.take();
                       runnable.run();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
            });
            t.start();
        }
    }
}

public class Demo25 {
    public static void main(String[] args) {
        MyThreadPool myThreadPool = new MyThreadPool(10);
        for (int i = 0; i < 100; i++) {
            myThreadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello");
                }
            });
        }
    }
}

!Thread.currentThread().isInterrupted() ：1.判断标志类 2.判断线程有没有中断，中断了就不继续走