Java多线程案例(二)

Timer

在软件开发中，经常需要实现定时执行任务的功能。为了实现这个目标，我们可以设计一个简单的定时器。在这个项目中，我们将介绍如何使用 Java 来实现一个基于优先队列的定时器。

1. Task 类

首先，我们定义一个 Task 类来表示任务。每个任务对象包含一个 runnable 对象和一个表示任务执行时间的 time 字段。为了能够比较任务的执行时间，我们让 Task 类实现 Comparable 接口，并重写 compareTo 方法,以便让其在能在优先级队列中存储。

class Task implements Comparable<Task> {
    Runnable runnable = null;
    long time;//记录的是实际发生事件的时间戳
    @Override
    public int compareTo(Task o) {
        return (int) (this.time - o.time);
    }

    public Task(Runnable runnable, long delay) {
        this.runnable = runnable;
        this.time = System.currentTimeMillis() + delay;
    }
}

由于我们需要让任务从时间戳小的执行到时间戳大的，所以我们重写的compareTo方法也要基于这个，然后利用优先级队列的相对有序实现总是取到时间最短的任务 

2.MyTimer 的定时器类，其中包含一个优先队列用于存储任务：

public class MyTimer {
    //这里要用一个数据结构来存储实现runnable接口的对象，以及其发生的时间，直觉上我们可以使用TreeMap(有key与value),但查找需要O（logN）
    //于是，我们使用PriorityQueue来实现，我一开始想的是里面存的可以是一个hashMap（用hashMap来封装），但这样相当于只为了一个Map，创建了过多的空间
    //那我们不如把runnable对象与时间直接封装
    //这里不直接调用阻塞队列->？
    private Object locker = new Object();
    //数据结构不过关，优先级队列大小无限
    PriorityQueue<Task> priorityQueue = new PriorityQueue<>();

    //线程在哪创建比较合理？1.Timer的构造方法 2.第一次调用 schedule
    //这里使用1
    //在构造方法中创建线程，并执行线程的任务
    public MyTimer() {
        Thread thread = new Thread(() -> {
            while (true) {
                synchronized (locker) {
                    //为空，等待,有加入就唤醒
                    while (priorityQueue.isEmpty()) {
                        try {
                            locker.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    Task curtask = priorityQueue.peek();
                    //时间不到，等待，有加入就唤醒（可能有更新的时间）
                    curtask = priorityQueue.peek();
                    while (curtask.time > System.currentTimeMillis()) {
                        long delta = curtask.time - System.currentTimeMillis();
                        try {
                            locker.wait(delta);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        curtask = priorityQueue.peek();
                    }
                    curtask.runnable.run();
                    priorityQueue.poll();
                    //locker.notifyAll();
                }
            }
        });
        thread.start();
    }

固定线程数的线程池 

在这段代码中，我们尝试实现一个简单的固定线程数的线程池 MyThreadPool，该线程池可以接收任务，并且通过固定数量的线程来执行这些任务。

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

public class MyThreadPool {
    private final int DEFAULT_Thread_SIZE = 4; // 默认线程数
    private final int DEFAULT_Task_SIZE = 10; // 默认任务队列大小
    private BlockingDeque<Runnable> blockingDeque = new LinkedBlockingDeque<>(DEFAULT_Task_SIZE); // 任务队列
    private List<Thread> threadList = new ArrayList<>(); // 线程列表

    public MyThreadPool() {
        // 创建线程并启动
        for (int i = 0; i < DEFAULT_Thread_SIZE; i++) {
            Thread thread = new Thread(() -> {
                // 循环从任务队列中取任务并执行
                while (true) {
                    try {
                        blockingDeque.take().run();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            threadList.add(thread);
            thread.start();
        }
    }

    // 提交任务到任务队列中
    public void submit(Runnable task) throws InterruptedException {
        blockingDeque.put(task);
    }
}

1. 任务队列：使用 LinkedBlockingDeque 来作为任务队列，它是一个基于链表的阻塞队列，具有无界容量。

2. 线程列表：使用 List<Thread> 来保存线程对象，方便后续管理。

3. 线程池初始化：在构造方法中，通过循环创建指定数量的线程，并启动这些线程。每个线程会不断地从任务队列中取出任务并执行。

4. 任务提交：通过 submit() 方法向任务队列中提交任务。这个方法将任务放入队列中，如果队列已满则会阻塞直到有空间可用。

5. 注意事项：在 submit() 方法中，我们使用了 put() 方法将任务放入队列中，它会阻塞当前线程直到有空间可用。这样可以避免因任务队列已满而导致的任务丢失。

注意：虽然这里run方法没有跑完，能实现在 new Thread(...) 这个构造方法名。这是因为

在Java中，Thread对象的构造函数并不会等待run方法执行完毕，它仅仅是创建了一个新的线程对象，并开始执行run方法。因此，即使run方法中有阻塞操作，也不会影响到线程对象的创建。

在代码中，new Thread(...)这个构造方法会创建一个新的线程对象，然后通过调用start()方法来启动线程执行其中的run方法。即使在run方法内部有阻塞操作，这并不会影响线程对象的创建。因此，即使阻塞队列为空，线程对象也会被创建成功，并且开始等待队列中有任务到来。

简而言之，线程对象的创建与其run方法的执行是异步的，线程对象的创建并不会等待run方法的执行完成。线程的创建都不会等待任务执行完成。这是 Java 线程模型的基本特性。