如何正确地取消Java任务或服务？

最新推荐文章于 2025-03-25 08:30:00 发布
原创 最新推荐文章于 2025-03-25 08:30:00 发布 · 1.8k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言 #后端

本文详细探讨了如何在Java中正确取消任务和服务。从任务取消的常见方法，如利用Interrupt机制、Future的cancel方法，到服务取消，如ExecutorService的生命周期管理，以及在生产者-消费者模型中采用自定义标志和‘毒药’法。同时，讨论了线程异常退出、JVM关闭以及守护线程的角色，提供了最佳实践和注意事项。

引言

取消正在执行的任务、线程、服务，并不是那么容易。对于某个任务而言，为了支持取消操作，你不得不增加取消的代码，而且不一定支持阻塞；对于服务而言更是如此，你不清楚服务内部是依赖什么实现，所以就无法正常取消。（例如，内部可能是阻塞队列，可能是多个Task）

任务取消

取消一个任务，或一段程序，最容易想到的操作是增加判断标志，每次执行的时候判断，否则退出程序。但自定义的变量并不能解决阻塞问题。例如下面代码，如果在循环中阻塞了，那么它永远无法判断取消标志。

while(!cancelled) {
	do something // block   
}

所以Java内部提供了Interrupt机制，它本质上就是一个boolean变量，只是底层（例如阻塞）对该标志有相应的支持，所以中断是实现取消的最合理的方式。

线程与任务

原始的API中，任务和线程通常是耦合在一起的。当我们说起取消任务的时候，实际上是中断运行任务的线程，或者利用中断标志给线程添加取消策略。
这里有一个原则：

除非你知道线程的中断策略，否则不要中断它

原因在于，中断机制本质上是一个协议，它除了设置中断标志之外，并没有做特别的处理，所以每个线程都有自己的中断策略（可能是无策略）。

延迟中断

我们知道Interrupt机制一般需要手动恢复中断，但是在以下情形恢复中断会造成死循环，所以必须采用延迟恢复的技术。

final AtomicBoolean interrupted = new AtomicBoolean(false);
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(2);

        try {
            while (true) {
                try {
                    Integer r = queue.take();
                    return;
                } catch (InterruptedException e) {
                    // 延迟中断标志
                    interrupted.set(true);
                    System.out.println("catch");
                    e.printStackTrace();
                }
            }
        } finally {
            // 恢复中断
            if (interrupted.get()){
                Thread.currentThread().interrupt();
            }
        }
    }
});

利用Future取消任务，定时取消任务

当我们使用Executor框架的时候，线程是由Executor创建的，我们不能直接去中断线程，因为我们不知道Executor正在运行什么任务。Executor使用一种抽象的机制来管理任务的生命周期，包括获得结果和取消任务。所以，一种更好的方式，就是利用Future的cancel方法来取消任务，这是非常方便的。
由于任务执行时间是不确定的，设定期望执行时间，应该是一种常见的操作，以下提供一种最佳实践。

public void futureTimedRun(Runnable runnable, long timeout, TimeUnit timeUnit) {
    Future<?> future = executor.submit(runnable);
    try {
        future.get(timeout, timeUnit);
    } catch (InterruptedException e) {
        // 处理中断
        e.printStackTrace();
    } catch (ExecutionException e) {
        // 处理执行时异常
        e.printStackTrace();
    } catch (TimeoutException e) {
        // 超时处理
        e.printStackTrace();
    } finally {
        // 取消不再需要的任务
        future.cancel(true);
    }
}

作为对比，这里也给出一种不好的做法——利用ScheduledExecutor延迟执行，取消任务。
这里的问题是：

  1. 违背原则，不知道线程的中断策略，就不能操控它。你不知道它是否响应中断，是否继续执行
  2. 如果任务执行异常，无法捕获。你也不知道它究竟是执行异常还是超时异常，还是中断
public void timedRun(Runnable runnable, long timeout, TimeUnit timeUnit) {
    // 启动线程
    final Thread thread = new Thread(runnable);
    thread.start();
    // 定时取消任务
    executor.schedule(new Runnable() {
        @Override
        public void run() {
            thread.interrupt();
        }
    }, timeout, timeUnit);
}

取消不可中断的阻塞

并不是所有阻塞都会响应interrupt，例如各种IO操作，例如Lock的lock方法。
这个时候，我们就需要了解它们各自的中断机制，编写整体任务的中断策略。
例如：

  • Socket IO，中断可以通过关掉socket对象实现
  • Lock，实际上提供了可中断的加锁方法lockInterruptibly

以Socket为例，编写自定义的中断策略。

public class ReaderThread extends Thread {
    //...

    /**
     * 其实就是 socket的中断方法 + 线程的中断方法
     */
    public void interrupt() {
        try {
            socket.close();
        } catch (IOException ignored) {
        } finally {
            super.interrupt();
        }
    }
}

如果是以Executor的形式实现，那自定义中断策略就比较复杂了。Executor是通过FutureTask来实现取消操作的，因此，你必须完成两件事：

  1. 拓展FutureTask，实现自定义的取消策略
  2. 拓展Executor，新建自定义的FutureTask

这部分比较复杂，请参考源码（Chapter07，taskcancel.noninterruptable.CancellableTask）。

服务取消

服务通常会基于线程编写，不同的实现方式需要不同的中断策略。

Executor

基于Executor管理线程应该是最常用的，幸运的是，如果不用考虑任务的中断恢复的话，Executor机制本身已经提供了非常方便的中断方式——ExecutorService的生命周期。

/**
 * 直接停止，并且阻塞等待，固定时间
 */
public void stop() throws InterruptedException {
    try {
        exec.shutdown();
        exec.awaitTermination(3000, TimeUnit.MILLISECONDS);
    } finally {
        /* 关闭其他资源，例如io */
    }
}

此外，如果是一次执行的任务，那么记得手动关闭Executor。


/**
 * 如果ExecutorService只执行一次，那么可以直接在finally关闭
 * <p>
 * 案例：并发检查多个地址的邮件是否更新，有则设置更新标志
 */
boolean checkMail(Set<String> hosts, long timeout, TimeUnit unit)
        throws InterruptedException {
    ExecutorService exec = Executors.newCachedThreadPool();
    final AtomicBoolean hasNewMail = new AtomicBoolean(false);
    try {
        for (final String host : hosts)
            exec.execute(new Runnable() {
                public void run() {
                    if (checkMail(host))
                        hasNewMail.set(true);
                }

                private boolean checkMail(String host) {
                    /* 检查邮件 */
                    return false;
                }
            });
    } finally {
        exec.shutdown();
        exec.awaitTermination(timeout, unit);
    }
    return hasNewMail.get();
}

生产者-消费者模型

这是一种管理有限资源的常用模型，通常使用阻塞队列编写。

自定义标志

基本理念：中断标记之后，停止生产，消费完成允许中断**。**需要使用同步保证变量访问的原子性。

/**
 * 中断基于线程的服务-中断生产者消费者服务
 * <p>
 * 案例：
 * 日志记录服务，拥有固定的消费线程，处理日志。多个调用者线程生产日志（生产者）
 * <p>
 * 需要小心编写写中断服务。
 * 有时候不仅是中断线程，正如本例，中断生产者-消费者模型，这是一种方式。
 * 基本理念：中断标记之后，停止生产，消费完成允许中断
 */
public class LogWriter {
...

    /**
     * 1. 中断消费线程。
     * 但是生产效率大于消费效率，会阻塞在队列上导致无法中断。
     */
    public void stop() {
        synchronized (this) {
            shutdown = true;
        }
        logger.interrupt();
    }

    /**
     * 2. 增加shutdown标志，关闭后不再生产，避免生产者阻塞。
     * 但是shutdown的判断修改为竞态条件，需要同步
     *
     */
    public void log(String msg) throws InterruptedException {
        synchronized (this) {
            if (shutdown) {
                System.out.println("has shutdown");
                return;
            }
        }
        queue.put(msg);
    }

    private class LoggerThread extends Thread {
        /**
         * 3. 判断关闭且队列消费完毕，退出。同样注意竞态条件
         */
        public void run() {

            while (true) {
                synchronized (LogWriter.this) {
                    if (shutdown && queue.size() == 0) {
                        break;
                    }
                }
                consume();
            }

        }

        private void consume() {
            try {
                System.out.println(queue.take());
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // 允许忽略中断标志，上一层已经有中断策略
            }
        }
    }
}

“毒药”法

POISON法： 理念是生产者被中断添加POISON标志，并且不会再生产；等待消费者消费，消费者看到POISON直接退出。 注意，在n个生产者需要添加n个POISON标志。


/**
 * 中断基于线程的服务-中断生产者消费者服务
 * <p>
 * 案例：
 * 索引建立服务，生产线程不断添加文件路径，消费线程不断对路径建立索引
 * <p>
 * POISON法：
 * 理念是生产者被中断添加POISON标志，并且不会在生产；等待消费者消费完成，消费者看到POISON直接退出。
 * 注意，在n个生产者需要添加ngePOISON标志
 */
public class IndexingService {
...

    /**
     * 生产线程
     */
    class CrawlerThread extends Thread {
        public void run() {
            try {
                crawl(root);
            } catch (InterruptedException e) { /* fall through */ } finally {
                // 2. 生产者被中断之后，添加POISON
                // 注意，如果有n个生产者，每个生产者应该各自添加POISON
                while (true) {
                    try {
                        System.out.println("中断，添加POISON");
                        queue.put(POISON);
                        break;
                    } catch (InterruptedException e1) { /* retry */ }
                }
            }
        }

        private void crawl(File root) throws InterruptedException {
            /* 添加路径到队列等待建立索引*/
            for (int i = 0; i < 1000; i++) {
                queue.put(new File(i + ""));
                Thread.sleep(100);
            }

        }
    }

    /**
     * 消费者线程
     */
    class IndexerThread extends Thread {
        public void run() {
            try {
                // 3. 消费者如果看到POISON则立即退出
                while (true) {
                    Thread.sleep(150);
                    File file = queue.take();
                    if (file == POISON)
                        break;
                    else
                        indexFile(file);
                }
            } catch (InterruptedException consumed) {
                // 允许中断
            }
        }

        private void indexFile(File file) {
            /* 建立索引 */
            System.out.println("indexing " + file.getAbsolutePath());
        }
    }

    public void start() {
        producer.start();
        consumer.start();
    }

    /**
     * 1. 中断服务，中断生产者
     */
    public void stop() {
        producer.interrupt();
    }

    /**
     * 等待的同步阻塞
     */
    public void awaitTermination() throws InterruptedException {
        consumer.join();
    }


}

任务断点恢复

上文提到Executor的shutdown方法，该方法调用之后会等待任务执行完成，然后关闭。如果任务一直没执行完，能否强制关闭呢？答案是肯定的，Executor提供了shutdownNow方法，该方法调用之后，会立即尝试结束正在运行线程，并返回已经提交未执行完的任务。
但这样一来，其实无法恢复程序状态——因为正在运行的任务被取消了，我们并不知道是哪些。
​

这种断点恢复是很有用的，例如爬虫程序，下载断点恢复等等。这个时候就需要拓展Executor，收集执行中被中断的任务。

/**
 * 中断基于线程的服务-支持断点恢复的服务的实现
 *
 */
public class TrackingExecutor extends AbstractExecutorService {
    private final ExecutorService exec;
    private final Set<Runnable> tasksCancelledAtShutdown =
            Collections.synchronizedSet(new HashSet<Runnable>());

    public List<Runnable> getCancelledTasks() {
        if (!exec.isTerminated())
            throw new IllegalStateException();
        return new ArrayList<Runnable>(tasksCancelledAtShutdown);
    }

    public void execute(final Runnable runnable) {
        // 任务增强，包装一层，在任务结束后（不管是正常结束还是被中断），判断是否任务执行期间被中断，是则添加到列表中
        exec.execute(new Runnable() {
            public void run() {
                try {
                    runnable.run();
                } finally {
                    if (isShutdown()
                            && Thread.currentThread().isInterrupted())
                        tasksCancelledAtShutdown.add(runnable);
                }
            }
        });
    }

    /*
    * 将其他方法委托给exec
    * */

}

该Executor的使用如下。完整代码请参考github。

/**
 * 案例：爬虫程序断点恢复
 */
public class WebCrawler {
...
    
    /**
     * 演示了如何使用支持断点恢复的Executor
     * <p>
     * 1. 调用{@code exec.shutdownNow()}，保存已经提交未开始的任务
     * <p>
     * 2. 调用{@code exec.getCancelledTasks()}，保存正在执行被取消的任务
     */
    public synchronized void stop() throws InterruptedException {
        try {
            saveUncrawled(exec.shutdownNow());
            // 等待5秒，如果exec正常结束则返回true，否则返回false
            if (exec.awaitTermination(5000, TimeUnit.MILLISECONDS))
                saveUncrawled(exec.getCancelledTasks());
        } finally {
            exec = null;
        }
    }
}

线程异常退出，线程泄漏

线程泄漏是指线程执行过程中遇到未捕获异常没有处理，最终导致程序卡住或异常。
那么，如何处理未捕获异常呢？两种方式。

try-catch

    public void run() {
        Throwable thrown = null;
        try {
            while (!isInterrupted())
                runTask(getTaskFromWorkQueue());
        } catch (Throwable e) {
            thrown = e;
        } finally {
            // 处理未捕获异常
            threadExited(this, thrown);
        }
    }

UncaughtExceptionHandler

Thread API提供了UncaughtExceptionHandler异常处理器，当一个线程由于未捕获异常而退出时，JVM会把这件事报告给应用程序提供的UncaughtExceptionHandler异常处理器。
在运行较长的应用程序中，通常会给所有线程设置一个异常处理器，例如将异常记录到日志中。

public interface UncaughtExceptionHandler {
    void uncaughtException(Thread t, Throwable e);
}

JVM关闭

JVM可以正常关闭和强制关闭（例如外部kill），那么我们需要了解哪些和JVM关闭有关的知识呢？

守护线程

守护线程是什么

Java程序入口就是由JVM启动main线程，main线程又可以启动其他线程。当所有线程都运行结束时，JVM退出，进程结束。
如果有一个线程没有退出，JVM进程就不会退出。所以，必须保证所有线程都能及时结束。
但是有一种线程的目的就是无限循环，例如，一个定时触发任务的线程：

class TimerThread extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println(LocalTime.now());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                break;
            }
        }
    }
}
// 使用
Thread t = new MyThread();
t.setDaemon(true);
t.start();

如果这个线程不结束，JVM进程就无法结束。问题是，由谁负责结束这个线程？
然而这类线程经常没有负责人来负责结束它们。但是，当其他线程结束时，JVM进程又必须要结束，怎么办？
答案是使用守护线程（Daemon Thread）。
守护线程是指为其他线程服务的线程。在JVM中，所有非守护线程都执行完毕后，无论有没有守护线程，虚拟机都会自动退出。
hef: https://www.liaoxuefeng.com/wiki/1252599548343744/1306580788183074

最佳实践

JVM退出的时候，如果发现只剩下守护线程，那么它就会正常退出，所有存在的守护线程会被抛弃——不会执行finally，回收等，直接结束。
正因为如此，我们要尽可能地少用守护线程，因为很少有线程能够在完全不清理的情况下直接抛弃。守护线程最好只用于内部任务。

finalize

Java提供了finalization的机制——一个对象被GC之前，会调用finalize()方法。它很像c++的析构方法，但由于Java是由虚拟机管理GC，使得它在功能上和析构方法完全不同。

  • finalize的执行时机完全无法保证，它只和GC的时机有关
  • finalize方法之后对象不一定回收，它可以复活某个对象
  • 糟糕的finalize实现会极大地影响GC效率

所以：

不要使用finalize！
除了用于回收native资源。

关闭钩子

关闭钩子是JVM的一种机制，在正常结束前会调用所有已经注册的关闭钩子（通常是一个线程）。它的注册非常简单：

public void start() {
    Runtime.getRuntime().addShutdownHook(new Thread() {
        public void run() {
            try { LogService.this.stop(); }
            catch (InterruptedException ignored) {}
        }
    });
}

注意，所有关闭钩子（线程）都是并发执行的，要注意清理资源时的并发安全问题。如果多种资源有依赖（例如某些资源关闭可能需要依赖日志服务，如果日志服务被关闭钩子关闭，那就会出问题），那么可以使用单一关闭钩子的技术——所有服务都使用同一个关闭钩子进行资源清理，这个线程可以串行地关闭多个资源，避免依赖问题。

源码

https://github.com/KDL-in/JavaConcurrentDemo/tree/master/Chapter07/src/main/java

java.exe 关闭后自动重启
【优快云】
09-02 1702
DOC —— msconfig —— 以下界面 点击启动： 以下操作： 每一个任务项勾选不需要的服务 ）——应用 ）——确定 然后去任务管理器 关闭java.exe服务 如果还是重启 多关闭几次。 能帮你的就到这里了，此致敬礼！ ...
Java高频面试基础问题与知识点整理
热门推荐
张彦峰的博客
11-04 171万+
Java高频面试知识点总结：覆盖高频基础知识考点+高频集合知识点深入分析+高频多线程与并发编程面试题汇总+其他扩展考察等。
2.windows系统：定时任务关闭Java服务
qq_37992410的博客
04-08 1938
做一个定时任务在每天21:30关闭Java服务。
启动停止java服务的shell脚本
09-19
启动停止java服务的shell脚本，可以用于微服务，springboot服务，java普通进程，等等都可以 需要积分的话是系统自动涨的，每次有人下载它就会自动给涨，我会定期改成0分
JVM安全退出（如何优雅的关闭java服务）
java、c++、机器学习方向King
06-20 3万+
https://tech.imdada.cn/2017/06/18/jvm-safe-exit/?utm_source=tuicool&utm_medium=referral 背景 用户：货都到了，购物车里怎么还有刚买的东西，what? 产品：有用户反映，提单完成了，怎么没清购物车，研发赶紧看看是不是有bug啊？ 研发：恩，我看看，！@#￥%……&*（）一顿狂查，搜嘎，当时在上
java 取消方法事务_java-使用Spring时如何手动取消JPA或Hibernate事务
weixin_30660429的博客
03-02 2261
我正在使用JPA 2 Hibernate实现和Spring MVC来管理事务我正在使用通用DAO模式来管理数据库操作当前,我们有一个单一方法的事务,例如：someDao.save (someObject)这是从JSF页面调用的@Transactional方法.方法save是从Generic DAO继承的,它持久地存储到具有级联oneToMany关系的许多实体的数据库中,但是它必须在数据库中执行几千...
14、java如何正确关闭线程池？
zht245648124的博客
04-12 1715
在掌握了这 5 种关闭线程池相关的方法之后，我们就可以根据自己的业务需要，选择合适的方法来停止线程池，比如通常我们可以用 shutdown() 方法来关闭，这样可以让已提交的任务都执行完毕，但是如果情况紧急，那我们就可以用 shutdownNow 方法来加快线程池“终结”的速度。正常停止线程的本质，是让线程任务的run方法执行完，对应到线程池的线程，就是Worker类的run方法执行完。这个run方法执行完的前提是getTask()返回的是null。
Java定时任务详解
最新发布
weixin_52749896的博客
03-25 1274
在Java开发中，定时任务是一个常见的需求，比如定时备份数据、定时清理日志、定时发送邮件等。Java提供了多种实现定时任务的方式，本文将详细介绍Java中定时任务的实现方式、底层逻辑、使用方法以及示例代码。Timer 和 TimerTask：简单易用，但功能有限，不适合复杂场景。ScheduledExecutorService：基于线程池，提供了更好的性能和灵活性。Spring Task Scheduler：适合Spring项目，简化了定时任务的开发。
如何在使用Java Scheduler的scheduleAtFixedRate方法执行完任务后正确地关闭调度？
11-24
为了确保任务完成后能够正确地关闭调度，你需要按照以下步骤操作： 1. 创建一个ScheduledFuture对象，这是`scheduleAtFixedRate`方法返回的结果，你可以通过这个对象取消、更改或者获取任务的状态。 ```java ...
java在服务启动的时候启动定时器
09-20
Java在服务启动时启动定时器是一项常见的需求，用于执行定期任务，例如数据同步、日志清理、健康检查等。...在实际应用中，我们还需要考虑服务的生命周期，确保在服务停止时正确地关闭定时器，避免资源泄露。
Java使用ExecutorService来停止线程服务
08-19
主要介绍了Java使用ExecutorService来停止线程服务，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java应用程序窗口关闭的六种方法
01-03
Java应用程序窗口关闭的六种方法。。。。。。。。。。。
java 停止服务_java中如何优雅的停止服务
weixin_30395941的博客
02-15 2677
强制进程退出的副作用：缓存中的数据尚未持久化到磁盘中，导致数据丢失；正在进行文件的write操作，没有更新完成，突然退出，导致文件损坏；线程池的任务队列中尚有接收到的任务还没来得及处理，导致任务丢失；数据库操作已经完成，例如账户余额更新，准备返回应答消息给客户端时，消息尚在通信线程的发送队列中排队等待发送，进程强制退出导致应答消息没有返回给客户端，客户端发起超时重试，会带来重复更新问题；其它问题等...
java关闭服务_java – 活动关闭时服务停止
weixin_42202078的博客
02-12 575
我已经阅读了一些与这个问题相关的答案,它们似乎都是一样的：“使用START_STICKY运行您的服务”“在前台运行您的服务”“使用startService运行您的服务,不要绑定它”我正在做所有这些事情,我的服务STILL关闭并在每次关闭活动时重新启动.这不是IntentService.我也没有在onClick处理程序中调用stopSelf或stopService.从MainActivity启动我的...
java关闭服务_如何正确关闭java ExecutorService
weixin_30563851的博客
02-20 672
胡说叔叔从ExecutorService的Oracle API文档页面推荐的方法：voidshutdownAndAwaitTermination(ExecutorServicepool){pool.shutdown();//Disablenewtasksfrombeingsubmittedtry{//Waitawhileforexistin...
java服务怎么关闭_windows 10系统怎么关闭更新服务？
weixin_42407606的博客
01-26 1070
1.按快捷键：win+R，输入“services.msc”并回车，打开服务管理窗口，找到“Windows Update”服务，点击“停止”。2.选择“Windows Update”服务，点击鼠标右键——>"属性"，在常规选项卡中把启动类型改为"禁止"，然后点击"恢复"选项卡，把“第一次失败”“第二次失败，“后续失败”后面的选项都改为“无操作”，具体操作步骤如下截图。3.再次按win+R快捷键...
java服务怎么停_Spring Boot如何优雅地停止服务
weixin_31099497的博客
02-28 764
作者：黄青石 来源：博客园前言在使用Springboot的时候，都要涉及到服务的停止和启动，当我们停止服务的时候，很多时候大家都是kill -9 直接把程序进程杀掉，这样程序不会执行优雅的关闭。而且一些没有执行完的程序就会直接退出。我们很多时候都需要安全的将服务停止，也就是把没有处理完的工作继续处理完成。比如停止一些依赖的服务，输出一些日志，发一些信号给其他的应用系统，这个在保证系统的高可用是非常...
停止java服务
qq_40097074的博客
07-16 2258
停止一个java服务，只需要调用System.exit（int state）方法 JAVA System.exit(0) 和 System.exit(1) 的区别 System.exit(int state) 方法都是来结束当前运行的java虚拟机。所有System.exit(1)、System.exit(0) 执行后都会退出程序。 state为0时时正常退出，非0时为异常退出。所以System....
命令行停止Java服务
weixin_41275895的博客
08-26 231
我整理的一些关于【Java】的项目学习资料（附讲解～～）和大家一起分享、学习一下：https://d.51cto.com/bLN8S1如何通过命令行停止Java服务 在开发和运维过程中，有时我们需要停止正在运行的Java服务。掌握这一技巧，对于一个初入职场的开发者来说是至关重要的。本文将详细介绍如何通过命令行停止Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值