湫枫染墨

线程池

3/7/2023 Java

心灵鸡汤

绝大部分人，在绝大部分时候，都只能靠自己。没有什么背景，没碰到什么贵人，也没读什么好学校，这些都不碍事。关键是，你决心要走哪条路，想成为什么样的人，准备如何对自己的懒惰下手。往前走，相信梦想并坚持。只有这样，你才有机会自我证实，找到你想要的尊严，不管你在哪个城市

# 一：线程池的使用

合理地使用线程池能够带来3个好处：

  1. 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗；
  2. 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行；
  3. 提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。但是，要做到合理利用线程池，必须对其实现原理了如指掌。

# 1.1 线程池创建

通过ThreadPoolExecutor来创建一个线程池

new ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> runnableTaskQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler);
1

创建一个线程池时需要输入几个参数，如下。

  1. corePoolSize（线程池的基本大小）：当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小时就不再创建。如果调用了线程池的 prestartAllCoreThreads() 方法，线程池会提前创建并启动所有基本线程。

  2. maximumPoolSize（线程池最大数量）：线程池允许创建的最大线程数。如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。值得注意的是，如果使用了无界的任务队列这个参数就没什么效果。

  3. keepAliveTime（线程活动保持时间）：线程池的工作线程空闲后，保持存活的时间。所以，如果任务很多，并且每个任务执行的时间比较短，可以调大时间，提高线程的利用率。

  4. TimeUnit（线程活动保持时间的单位）：可选的单位有天（DAYS）、小时（HOURS）、分钟（MINUTES）、毫秒（MILLISECONDS）、微秒（MICROSECONDS，千分之一毫秒）和纳秒（NANOSECONDS，千分之一微秒）。

  5. runnableTaskQueue（任务队列）：用于保存等待执行的任务的阻塞队列。可以选择以下几个阻塞队列。

    • ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按FIFO（先进先出）原则对元素进行排序。
    • LinkedBlockingQueue：一个基于链表结构的阻塞队列，此队列按FIFO排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法 Executors.newFixedThreadPool() 使用了这个队列。
    • SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于 LinkedBlockingQueue，静态工厂方法 Executors.newCachedThreadPool 使用了这个队列。
    • PriorityBlockingQueue：一个具有优先级的无限阻塞队列。

  6. ThreadFactory：用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置更有意义的名字。使用开源框架guava提供的ThreadFactoryBuilder可以快速给线程池里的线程设置有意义的名字，代码如下。

new ThreadFactoryBuilder().setNameFormat("XX-task-%d").build();
1
  1. RejectedExecutionHandler（饱和策略）：当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是 AbortPolicy，表示无法处理新任务时抛出异常。在JDK 1.5中Java线程池框架提供了以下4种策略。
    • AbortPolicy：直接抛出异常。
    • CallerRunsPolicy：只用调用者所在线程来运行任务。
    • DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。
    • DiscardPolicy：不处理，丢弃掉。 当然，也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化存储不能处理的任务。

# 1.2 向线程池提交任务

可以使用两个方法向线程池提交任务，分别为 execute() 和 submit() 方法。

  1. execute() 方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功。通过以下代码可知 execute() 方法输入的任务是一个 Runnable 类的实例。
threadsPool.execute(new Runnable() {
	@Override
	public void run() {
		// ... ...
	}
});
1
2
3
4
5
6
  1. submit() 方法用于提交需要返回值的任务。线程池会返回一个 future 类型的对象，通过这个 future 对象可以判断任务是否执行成功，并且可以通过 future 的 get() 方法来获取返回值，get() 方法会阻塞当前线程直到任务完成，而使用 get(long timeout, TimeUnit unit) 方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。
Future<Object> future = executor.submit(harReturnValuetask);
    try {
    	Object s = future.get();
    } catch (InterruptedException e) {
    	// 处理中断异常
    } catch (ExecutionException e) {
    	// 处理无法执行任务异常
    } finally {
        // 关闭线程池
        executor.shutdown();
    }
1
2
3
4
5
6
7
8
9
10
11

# 1.3 关闭线程池

可以通过调用线程池的 shutdown 或 shutdownNow 方法来关闭线程池。它们的原理是遍历线程池中的工作线程，然后逐个调用线程的 interrupt 方法来中断线程，所以无法响应中断的任务可能永远无法终止。但是它们存在一定的区别： 1. shutdownNow 首先将线程池的状态设置成 STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表; 2. shutdown 只是将线程池的状态设置成 SHUTDOWN 状态，然后中断所有没有正在执行任务的线程。

只要调用了这两个关闭方法中的任意一个，isShutdown 方法就会返回 true。当所有的任务都已关闭后，才表示线程池关闭成功，这时调用 isTerminaed 方法会返回 true。至于应该调用哪一种方法来关闭线程池，应该由提交到线程池的任务特性决定，通常调用 shutdown 方法来关闭线程池，如果任务不一定要执行完，则可以调用 shutdownNow 方法。

# 1.4 线程池的监控

如果在系统中大量使用线程池，则有必要对线程池进行监控，方便在出现问题时，可以根据线程池的使用状况快速定位问题。可以通过线程池提供的参数进行监控，在监控线程池的时候可以使用以下属性： * taskCount：线程池需要执行的任务数量。 * completedTaskCount：线程池在运行过程中已完成的任务数量，小于或等于taskCount。 * largestPoolSize：线程池里曾经创建过的最大线程数量。通过这个数据可以知道线程池是否曾经满过。如该数值等于线程池的最大大小，则表示线程池曾经满过。 * getPoolSize：线程池的线程数量。如果线程池不销毁的话，线程池里的线程不会自动销毁，所以这个大小只增不减。 * getActiveCount：获取活动的线程数。

通过扩展线程池进行监控。可以通过继承线程池来自定义线程池，重写线程池的 beforeExecute、afterExecute 和 terminated 方法，也可以在任务执行前、执行后和线程池关闭前执行一些代码来进行监控。例如，监控任务的平均执行时间、最大执行时间和最小执行时间等。这几个方法在线程池里是空方法。

protected void beforeExecute(Thread t, Runnable r) { }
1

# 二：线程池实现原理

当向线程池提交一个任务之后，线程池处理这个任务流程图如下所示：

从图中可以看出，当提交一个新任务到线程池时，线程池的处理流程如下。

  1. 线程池判断核心线程池里的线程是否都在执行任务。如果不是，则创建一个新的工作线程来执行任务。如果核心线程池里的线程都在执行任务，则进入下个流程。

  2. 线程池判断工作队列是否已经满。如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。

  3. 线程池判断线程池的线程是否都处于工作状态。如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务。

ThreadPoolExecutor执行execute()方法的示意图，如下所示：

ThreadPoolExecutor执行execute方法分下面4种情况。

  1. 如果当前运行的线程少于corePoolSize，则创建新线程来执行任务（注意，执行这一步骤需要获取全局锁）。

  2. 如果运行的线程等于或多于corePoolSize，则将任务加入BlockingQueue。

  3. 如果无法将任务加入BlockingQueue（队列已满），则创建新的线程来处理任务（注意，执行这一步骤需要获取全局锁）。

  4. 如果创建新线程将使当前运行的线程超出 maximumPoolSize，任务将被拒绝，并调用 RejectedExecutionHandler.rejectedExecution() 方法。

下面通过源代码来看看是如何实现的，线程池执行任务的方法如下：

public void execute(Runnable command) {
	if (command == null)
		throw new NullPointerException();

    int c = ctl.get();
    // 如果线程数小于基本线程数，则创建线程并执行当前任务
    if (workerCountOf(c) < corePoolSize) {
    	if (addWorker(command, true))
    		return;
    	c = ctl.get();
    }
    // 如线程数大于等于基本线程数或线程创建失败，则将当前任务放到工作队列中
    if (isRunning(c) && workQueue.offer(command)) {
    	int recheck = ctl.get();
    	if (! isRunning(recheck) && remove(command))
    		reject(command);
    	else if (workerCountOf(recheck) == 0)
    		addWorker(null, false);
    }
    // 如果线程池不处于运行中或任务无法放入队列，并且当前线程数量小于最大允许的线程数量，
    // 则创建一个线程执行任务。
    else if (!addWorker(command, false))
    // 抛出RejectedExecutionException异常
    	reject(command);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

线程池创建线程时，会将线程封装成工作线程Worker，Worker在执行完任务后，还会循环获取工作队列里的任务来执行。可以从Worker类的 run() 方法里看到这点。

















 






































package java.util.concurrent;

public class ThreadPoolExecutor extends AbstractExecutorService {

	private final class Worker extends AbstractQueuedSynchronizer implements Runnable {
		public void run() {
            runWorker(this);
        }
        
        final void runWorker(Worker w) {
            Thread wt = Thread.currentThread();
            Runnable task = w.firstTask;
            w.firstTask = null;
            w.unlock(); // allow interrupts
            boolean completedAbruptly = true;
            try {
                while (task != null || (task = getTask()) != null) {
                    w.lock();
                    // 如果池正在停止，确保线程被中断；
                    // 如果不是，确保线程不被中断。
                    // 这需要在第二种情况下重新检查以在清除中断时处理 shutdownNow 竞争
                    if ((runStateAtLeast(ctl.get(), STOP) ||
                         (Thread.interrupted() &&
                          runStateAtLeast(ctl.get(), STOP))) &&
                        !wt.isInterrupted())
                        wt.interrupt();
                    try {
                        beforeExecute(wt, task);
                        Throwable thrown = null;
                        try {
                            task.run();
                        } catch (RuntimeException x) {
                            thrown = x; throw x;
                        } catch (Error x) {
                            thrown = x; throw x;
                        } catch (Throwable x) {
                            thrown = x; throw new Error(x);
                        } finally {
                            afterExecute(task, thrown);
                        }
                    } finally {
                        task = null;
                        w.completedTasks++;
                        w.unlock();
                    }
                }
                completedAbruptly = false;
            } finally {
                processWorkerExit(w, completedAbruptly);
            }
    	}
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

# 二：Executor框架

# 2.1 Executor框架的结构

Executor框架主要由3大部分组成如下。

  • 任务。包括被执行任务需要实现的接口：Runnable接口或Callable接口。
  • 任务的执行。包括任务执行机制的核心接口Executor，以及继承自Executor的ExecutorService接口。Executor框架有两个关键类实现了ExecutorService接口（ThreadPoolExecutor 和 ScheduledThreadPoolExecutor）。
  • 异步计算的结果。包括接口Future和实现Future接口的FutureTask类。

# 2.2 主要类和接口

Executor框架包含的主要的类与接口如下所示：

  • Executor是一个接口，它是Executor框架的基础，它将任务的提交与任务的执行分离开来。
  • ThreadPoolExecutor是线程池的核心实现类，用来执行被提交的任务。
  • ScheduledThreadPoolExecutor是一个实现类，可以在给定的延迟后运行命令，或者定期执行命令。ScheduledThreadPoolExecutor比Timer更灵活，功能更强大。
  • Future接口和实现Future接口的FutureTask类，代表异步计算的结果。
  • Runnable接口和Callable接口的实现类，都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor执行。

Executor框架的使用示意图如下所示。

  1. 主线程首先要创建实现 Runnable 或者 Callable 接口的任务对象。工具类Executors可以把一个Runnable对象封装为一个Callable对象（Executors.callable(Runnable task) 或 Executors.callable(Runnable task, Object resule)）。

  2. 然后可以把 Runnable对象 直接交给 ExecutorService 执行（ExecutorService.execute(Runnable command)）；或者也可以把 Runnable对象 或Callable对象提交给 ExecutorService 执行（ExecutorService.submit(Runnable task) 或 ExecutorService.submit(Callable<T> task)）。

  3. 如果执行 ExecutorService.submit(…)，ExecutorService将返回一个实现 Future 接口的对象（到目前为止的JDK中，返回的是FutureTask对象）。由于 FutureTask 实现了 Runnable，程序员也可以创建 FutureTask，然后直接交给 ExecutorService 执行。

  4. 最后，主线程可以执行 FutureTask.get() 方法来等待任务执行完成。主线程也可以执行 FutureTask.cancel(boolean mayInterruptIfRunning) 来取消此任务的执行。

# 2.3 Executor框架的成员

Executor框架的主要成员：ThreadPoolExecutor、ScheduledThreadPoolExecutor、Future接口、Runnable接口、Callable接口和Executors。

  1. ThreadPoolExecutor 通常使用工厂类Executors来创建。Executors可以创建3种类型的ThreadPoolExecutor：SingleThreadExecutor、FixedThreadPool 和 CachedThreadPool。
  • FixedThreadPool 适用于为了满足资源管理的需求，而需要限制当前线程数量的应用场景，它适用于负载比较重的服务器。下面是Executors提供的，创建使用固定线程数的FixedThreadPool的API。
public static ExecutorService newFixedThreadPool(int nThreads);

public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactorythreadFactory);
1
2
3
  • SingleThreadExecutor 下面是Executors提供的，创建使用单个线程的SingleThreadExecutor的API。适用于需要保证顺序地执行各个任务；并且在任意时间点，不会有多个线程是活动的应用场景。
public static ExecutorService newSingleThreadExecutor();

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory);
1
2
3
  • CachedThreadPool 大小无界的线程池，适用于执行很多的短期异步任务的小程序，或者是负载较轻的服务器。下面是Executors提供的，创建一个会根据需要创建新线程的CachedThreadPool的API。
public static ExecutorService newSingleThreadExecutor();

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory);
1
2
3
  1. ScheduledThreadPoolExecutor 通常使用工厂类Executors来创建。Executors可以创建2种类型的ScheduledThreadPoolExecutor，分别是 ScheduledThreadPoolExecutor、SingleThreadScheduledExecutor。
  • ScheduledThreadPoolExecutor 包含若干个线程的ScheduledThreadPoolExecutor。适用于需要多个后台线程执行周期任务，同时为了满足资源管理的需求而需要限制后台线程的数量的应用场景。下面是工厂类Executors提供的，创建固定个数线程的ScheduledThreadPoolExecutor的API。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize);

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory);
1
2
3
  • SingleThreadScheduledExecutor 只包含一个线程的ScheduledThreadPoolExecutor。适用于需要单个后台线程执行周期任务，同时需要保证顺序地执行各个任务的应用场景。适用于需要单个后台线程执行周期任务，同时需要保证顺序地执行各个任务的应用场景。下面是Executors提供的，创建单个线程的SingleThreadScheduledExecutor的API。
public static ScheduledExecutorService newSingleThreadScheduledExecutor();

public static ScheduledExecutorService newSingleThreadScheduledExecutor
(ThreadFactory threadFactory);
1
2
3
4
  1. Future接口和实现Future接口的FutureTask类用来表示异步计算的结果。当我们把Runnable接口或Callable接口的实现类提交（submit）给 ThreadPoolExecutor 或 ScheduledThreadPoolExecutor 时，ThreadPoolExecutor或ScheduledThreadPoolExecutor会向我们返回一个FutureTask对象。下面是对应的API。
<T> Future<T> submit(Callable<T> task);

<T> Future<T> submit(Runnable task, T result);

Future<?> submit(Runnable task);
1
2
3
4
5

有一点需要读者注意，到目前最新的JDK 8为止，Java通过上述API返回的是一个FutureTask对象。但从API可以看到，Java仅仅保证返回的是一个实现了Future接口的对象。在将来的JDK实现中，返回的可能不一定是FutureTask。

  1. Runnable接口和Callable接口的实现类，都可以被 ThreadPoolExecutor或 ScheduledThreadPoolExecutor执行。它们之间的区别是Runnable不会返回结果，而Callable可以返回结果。

下面是Executors提供的，把一个Runnable包装成一个Callable的API。

public static Callable<Object> callable(Runnable task)        // 假设返回对象Callable1
1

下面是Executors提供的，把一个Runnable和一个待返回的结果包装成一个Callable的API。

public static <T> Callable<T> callable(Runnable task, T result)      // 假设返回对象Callable2
1

当任务成功完成后我们执行 FutureTask.get()，那么如果提交的是对象Callable1，将返回null；如果提交的是对象Callable2，将返回result对象。

# 三：ThreadPoolExecutor详解

通过Executor框架的工具类Executors，可以创建3种类型的ThreadPoolExecutor。下面将分别介绍这3种ThreadPoolExecutor。

# 3.1 FixedThreadPool

FixedThreadPool被称为可重用固定线程数的线程池。下面是FixedThreadPool的源代码实现。

public static ExecutorService newFixedThreadPool(int nThreads) {
	return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
}
1
2
3

FixedThreadPool 的 corePoolSize 和 maximumPoolSize 都被设置为创建 FixedThreadPool 时指定的参数 nThreads。

当线程池中的线程数大于 corePoolSize 时，keepAliveTime 为多余的空闲线程等待新任务的最长时间，超过这个时间后多余的线程将被终止。这里把 keepAliveTime 设置为0L，意味着多余的空闲线程会被立即终止。

FixedThreadPool 的 execute() 方法的运行示意图如下：

  1. 如果当前运行的线程数少于 corePoolSize，则创建新线程来执行任务。
  2. 在线程池完成预热之后（当前运行的线程数等于corePoolSize），将任务加入 LinkedBlockingQueue。
  3. 线程执行完1中的任务后，会在循环中反复从 LinkedBlockingQueue 获取任务来执行。

FixedThreadPool 使用无界队列 LinkedBlockingQueue 作为线程池的工作队列（队列的容量为 Integer.MAX_VALUE）。使用无界队列作为工作队列会对线程池带来如下影响。 1. 当线程池中的线程数达到 corePoolSize 后，新任务将在无界队列中等待，因此线程池中的线程数不会超过 corePoolSize。 2. 由于1，使用无界队列时 maximumPoolSize 将是一个无效参数。 3. 由于1和2，使用无界队列时 keepAliveTime 将是一个无效参数。 4. 由于使用无界队列，运行中的 FixedThreadPool（未执行方法 shutdown() 或 shutdownNow()）不会拒绝任务（不会调用 RejectedExecutionHandler.rejectedExecution 方法）。

# 3.2 SingleThreadExecutor

SingleThreadExecutor 是使用单个worker线程的Executor。下面是SingleThreadExecutor的源代码实现。

public static ExecutorService newSingleThreadExecutor() {
	return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()));
}
1
2
3

SingleThreadExecutor 的 corePoolSize 和 maximumPoolSize 被设置为1。其他参数与 FixedThreadPool 相同。SingleThreadExecutor 使用无界队列 LinkedBlockingQueue 作为线程池的工作队列（队列的容量为 Integer.MAX_VALUE）。SingleThreadExecutor 使用无界队列作为工作队列对线程池带来的影响与 FixedThreadPool 相同。

SingleThreadExecutor 的 execute() 的运行示意图如下所示：

  1. 如果当前运行的线程数少于corePoolSize（即线程池中无运行的线程），则创建一个新线程来执行任务。

  2. 在线程池完成预热之后（当前线程池中有一个运行的线程），将任务加入 LinkedBlockingQueue。

  3. 线程执行完1中的任务后，会在一个无限循环中反复从 LinkedBlockingQueue 获取任务来执行。

# 3.3 CachedThreadPool

CachedThreadPool是一个会根据需要创建新线程的线程池。下面是创建CachedThreadPool的源代码。

public static ExecutorService newCachedThreadPool() {
	return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
}
1
2
3

CachedThreadPool 的 corePoolSize 被设置为0，即corePool为空；maximumPoolSize被设置为 Integer.MAX_VALUE，即 maximumPool 是无界的。这里把 keepAliveTime 设置为60L，意味着 CachedThreadPool 中的空闲线程等待新任务的最长时间为60秒，空闲线程超过60秒后将会被终止。

CachedThreadPool 使用没有容量的 SynchronousQueue 作为线程池的工作队列，但CachedThreadPool 的 maximumPool 是无界的。这意味着，如果主线程提交任务的速度高于 maximumPool 中线程处理任务的速度时，CachedThreadPool 会不断创建新线程。极端情况下，CachedThreadPool 会因为创建过多线程而耗尽CPU和内存资源。

CachedThreadPool 的 execute() 方法的执行示意图如下所示：

  1. 首先执行 SynchronousQueue.offer(Runnable task)。如果当前 maximumPool 中有空闲线程正在执行 SynchronousQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)，那么主线程执行offer操作与空闲线程执行的 poll 操作配对成功，主线程把任务交给空闲线程执行， execute() 方法执行完成；否则执行下面的步骤2。

  2. 当初始maximumPool为空，或者maximumPool中当前没有空闲线程时，将没有线程执行 SynchronousQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)。这种情况下，步骤1 将失败。此时 CachedThreadPool 会创建一个新线程执行任务，execute() 方法执行完成。

  3. 在步骤2 中新创建的线程将任务执行完后，会执行 SynchronousQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)。这个poll操作会让空闲线程最多在 SynchronousQueue 中等待60秒钟。如果60秒钟内主线程提交了一个新任务（主线程执行步骤1）），那么这个空闲线程将执行主线程提交的新任务；否则，这个空闲线程将终止。由于空闲60秒的空闲线程会被终止，因此长时间保持空闲的CachedThreadPool不会使用任何资源。

前面提到过，SynchronousQueue 是一个没有容量的阻塞队列。每个插入操作必须等待另一个线程的对应移除操作，反之亦然。CachedThreadPool 使用 SynchronousQueue，把主线程提交的任务传递给空闲线程执行。CachedThreadPool 中任务传递的示意图如下所示。

# 四：ScheduledThreadPoolExecutor详解

# 五：参考文献

  • 《Java并发编程的艺术 - 方腾飞》
最后更新: 3/13/2023, 7:33:05 PM

时间日期