Java等待所有的线程运行结束解决方案总结（8种）

最新推荐文章于 2024-06-02 21:10:39 发布
最新推荐文章于 2024-06-02 21:10:39 发布
阅读量1.1w 收藏 36
点赞数 11
文章标签： join CountDownLatch wait/notifyAll ExecutorService Semaphore
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dap769815768/article/details/94601672
版权

Java架构师交流群：793825326

java版本：jdk1.8

IDE：Idea2019

实际开发中，经常会碰到这种问题，某个线程需要等待所有的线程执行结束了，才可以继续执行。要实现这个效果，Java中有很多方案，下面我列举一些我所知道的方案：

方案一：join。代码如下：

Thread thread1=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("thread1 start");
                    for (int i=0;i<10;i++)
                    {
                        Thread.sleep(500);
                        System.out.println("thread1 is working");
                    }
                    System.out.println("thread1 end");
                }
                catch (Exception ex) {System.out.println(ex.toString());}
            }
        });

        Thread thread2=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("thread2 start");
                    for (int i=0;i<5;i++)
                    {
                        Thread.sleep(500);
                        System.out.println("thread2 is working");
                    }
                    System.out.println("thread2 end");
                }
                catch (Exception ex) {System.out.println(ex.toString());}
            }
        });

        Thread thread3=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("thread3 start");

                    System.out.println("thread3 end");
                }
                catch (Exception ex) {System.out.println(ex.toString());}
            }
        });
        try {
            thread1.start();
            thread2.start();
            thread1.join();
            thread2.join();
            thread3.start();

        }
        catch (Exception ex)
        {
            System.out.println(ex.toString());
        }
}

该段代码的运行结果如下：

thread1 start
thread2 start
thread1 is working
thread2 is working
thread2 is working
thread1 is working
thread1 is working
thread2 is working
thread1 is working
thread2 is working
thread1 is working
thread2 is working
thread2 end
thread1 is working
thread1 is working
thread1 is working
thread1 is working
thread1 is working
thread1 end
thread3 start
thread3 end

thread1.start();
thread2.start();
thread1.join();
thread3.start();
thread2.join();

join的作用是一个子线程加入到当前线程，并导致当前线程等待，让其中调用了join方法的子线程运行，直到子线程运行结束了才会继续往下执行，join不会阻塞代码往下执行，也就是说不会阻塞其他的线程Join，比如本例中虽然thread1.join();方法被调用了，并不妨碍thread2.join();的执行，即便你把这句代码放到thread3.start();之后：

其运行结果仍然是一样的：

thread2 start
thread1 start
thread2 is working
thread1 is working
thread1 is working
thread2 is working
thread1 is working
thread2 is working
thread2 is working
thread1 is working
thread2 is working
thread1 is working
thread2 end
thread1 is working
thread1 is working
thread1 is working
thread1 is working
thread1 is working
thread1 end
thread3 start
thread3 end

方案二：wait/notifyAll，代码如下：

private static Object lock=new Object();
private static final AtomicInteger count = new AtomicInteger(2);
public static void main(String[] args) {

    Thread thread1=new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                System.out.println("thread1 start");
                for (int i = 0; i < 10; i++) {
                    Thread.sleep(500);
                    System.out.println("thread1 is working");
                }
                System.out.println("thread1 end");
                synchronized (lock) {
                    if (count.decrementAndGet() == 0)
                        lock.notifyAll();
                }
            } catch (Exception ex) {
                System.out.println(ex.toString());
            }
        }
    });

    Thread thread2=new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                System.out.println("thread2 start");
                for (int i = 0; i < 5; i++) {
                    Thread.sleep(500);
                    System.out.println("thread2 is working");
                }
                System.out.println("thread2 end");
                synchronized (lock) {
                    if (count.decrementAndGet() == 0)
                        lock.notifyAll();
                }

            } catch (Exception ex) {
                System.out.println(ex.toString());
            }
        }
    });

    Thread thread3=new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                synchronized (lock) {
                    lock.wait();
                }
                System.out.println("thread3 start");

                System.out.println("thread3 end");
            } catch (Exception ex) {
                System.out.println(ex.toString());
            }
        }
    });
    try {
        thread1.start();
        thread2.start();
        thread3.start();
    }
    catch (Exception ex)
    {
        System.out.println(ex.toString());
    }
}

其执行结果如下：

thread1 start
thread2 start
thread2 is working
thread1 is working
thread1 is working
thread2 is working
thread1 is working
thread2 is working
thread2 is working
thread1 is working
thread1 is working
thread2 is working
thread2 end
thread1 is working
thread1 is working
thread1 is working
thread1 is working
thread1 is working
thread1 end
thread3 start
thread3 end

这方法其实本质上和加锁的区别就是把耗时的代码不加锁，然后增加一个标记量来判断是否让thread3开始执行罢了。

方法三：CountDownLatch，代码如下：

private static final CountDownLatch latch=new CountDownLatch(2);
    public static void main(String[] args) {

        Thread thread1=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("thread1 start");
                    for (int i = 0; i < 10; i++) {
                        Thread.sleep(500);
                        System.out.println("thread1 is working");
                    }
                    System.out.println("thread1 end");
                    latch.countDown();
                } catch (Exception ex) {
                    System.out.println(ex.toString());
                }
            }
        });

        Thread thread2=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("thread2 start");
                    for (int i = 0; i < 5; i++) {
                        Thread.sleep(500);
                        System.out.println("thread2 is working");
                    }
                    System.out.println("thread2 end");
                    latch.countDown();
                } catch (Exception ex) {
                    System.out.println(ex.toString());
                }
            }
        });

        Thread thread3=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    latch.await();
                    System.out.println("thread3 start");
                    System.out.println("thread3 end");
                } catch (Exception ex) {
                    System.out.println(ex.toString());
                }
            }
        });
        try {
            thread1.start();
            thread2.start();
            thread3.start();
        }
        catch (Exception ex)
        {
            System.out.println(ex.toString());
        }
}

运行结果如下：

thread1 start
thread2 start
thread1 is working
thread1 is working
thread2 is working
thread2 is working
thread1 is working
thread2 is working
thread1 is working
thread2 is working
thread1 is working
thread2 is working
thread2 end
thread1 is working
thread1 is working
thread1 is working
thread1 is working
thread1 is working
thread1 end
thread3 start
thread3 end

这个方法和方法二思路一样，增加一个标记量，通过判断标记量的值来确定代码是否继续执行。

方法四：ExecutorService，代码：

private static final ExecutorService EXECUTOR_SERVICE= Executors.newCachedThreadPool();
    public static void main(String[] args) {

        Thread thread1=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("thread1 start");
                    for (int i = 0; i < 10; i++) {
                        Thread.sleep(500);
                        System.out.println("thread1 is working");
                    }
                    System.out.println("thread1 end");
                } catch (Exception ex) {
                    System.out.println(ex.toString());
                }
            }
        });

        Thread thread2=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("thread2 start");
                    for (int i = 0; i < 5; i++) {
                        Thread.sleep(500);
                        System.out.println("thread2 is working");
                    }
                    System.out.println("thread2 end");
                } catch (Exception ex) {
                    System.out.println(ex.toString());
                }
            }
        });

        Thread thread3=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    if (EXECUTOR_SERVICE.awaitTermination(10,TimeUnit.SECONDS))
                    {
                        System.out.println("thread3 start");
                        System.out.println("thread3 end");
                    }
                } catch (Exception ex) {
                    System.out.println(ex.toString());
                }
            }
        });
        try {
            EXECUTOR_SERVICE.execute(thread1);
            EXECUTOR_SERVICE.execute(thread2);
            EXECUTOR_SERVICE.shutdown();
            thread3.start();
        }
        catch (Exception ex)
        {
            System.out.println(ex.toString());
        }
}

执行结果如下：

thread1 start
thread2 start
thread2 is working
thread1 is working
thread1 is working
thread2 is working
thread2 is working
thread1 is working
thread2 is working
thread1 is working
thread1 is working
thread2 is working
thread2 end
thread1 is working
thread1 is working
thread1 is working
thread1 is working
thread1 is working
thread1 end
thread3 start
thread3 end

这个方法和之前的区别是它限定了等待时间，其触发逻辑是：当thread1和thread2都执行结束了，则awaitTermination返回true，如果在限定的10s内还没结束，则10s时间到时返回false。

方法五：信号量Semaphore，代码如下：

private static final Semaphore semaphore=new Semaphore(2);
    public static void main(String[] args) {

        Thread thread1=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    semaphore.acquire();
                    System.out.println("thread1 start");
                    for (int i = 0; i < 10; i++) {
                        Thread.sleep(500);
                        System.out.println("thread1 is working");
                    }
                    System.out.println("thread1 end");
                    semaphore.release();
                } catch (Exception ex) {
                    System.out.println(ex.toString());
                }
            }
        });

        Thread thread2=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    semaphore.acquire();
                    System.out.println("thread2 start");
                    for (int i = 0; i < 5; i++) {
                        Thread.sleep(500);
                        System.out.println("thread2 is working");
                    }
                    System.out.println("thread2 end");
                    semaphore.release();
                } catch (Exception ex) {
                    System.out.println(ex.toString());
                }
            }
        });

        Thread thread3=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    semaphore.acquireUninterruptibly(2);
                    System.out.println("thread3 start");
                    System.out.println("thread3 end");
                    semaphore.release();
                } catch (Exception ex) {
                    System.out.println(ex.toString());
                }
            }
        });
        try {
            thread1.start();
            thread2.start();
            thread3.start();
        }
        catch (Exception ex) {
            System.out.println(ex.toString());
        }
}

执行结果如下：

thread2 start
thread1 start
thread2 is working
thread1 is working
thread2 is working
thread1 is working
thread2 is working
thread1 is working
thread2 is working
thread1 is working
thread2 is working
thread2 end
thread1 is working
thread1 is working
thread1 is working
thread1 is working
thread1 is working
thread1 is working
thread1 end
thread3 start
thread3 end

这个方法的就是定义一个有两个许可证的信号量，thread3尝试去获取两个许可证，一开始它是获取不到的，因为会被thread1和thread2占用，那么它就会一直阻塞，直到这两个线程执行结束，thread3才拿到两个许可证，继续执行后面的代码。

方法六：自定义标记量（自旋锁），代码如下：

private static volatile int count=2;
    public static void main(String[] args) {

        Thread thread1=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("thread1 start");
                    for (int i = 0; i < 10; i++) {
                        Thread.sleep(500);
                        System.out.println("thread1 is working");
                    }
                    System.out.println("thread1 end");
                    count--;
                } catch (Exception ex) {
                    System.out.println(ex.toString());
                }
            }
        });

        Thread thread2=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("thread2 start");
                    for (int i = 0; i < 5; i++) {
                        Thread.sleep(500);
                        System.out.println("thread2 is working");
                    }
                    System.out.println("thread2 end");
                    count--;
                } catch (Exception ex) {
                    System.out.println(ex.toString());
                }
            }
        });

        Thread thread3=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (count>0);
                        System.out.println("thread3 start");
                        System.out.println("thread3 end");

                } catch (Exception ex) {
                    System.out.println(ex.toString());
                }
            }
        });
        try {
            thread1.start();
            thread2.start();
            thread3.start();
        }
        catch (Exception ex) {
            System.out.println(ex.toString());
        }
}

执行结果如下：

thread1 start
thread2 start
thread1 is working
thread2 is working
thread1 is working
thread2 is working
thread2 is working
thread1 is working
thread1 is working
thread2 is working
thread2 is working
thread2 end
thread1 is working
thread1 is working
thread1 is working
thread1 is working
thread1 is working
thread1 is working
thread1 end
thread3 start
thread3 end

这个方法实际上和方法三是一个道理，方法三的实现方案，如果你看了源码，你会发现它用了一个无限for循环。这里我们自己定义了一个标记量，如果这个标记量大于0，就一直循环等待，直到满足条件，代码继续往下执行。另外本例中的代码是有瑕疵的，count--;这步操作应该放到finally里面，这样才不会导致出现异常的时候thread3一直等待。

7.CyclicBarrier方法：

CyclicBarrier barrier=new CyclicBarrier(5);
for (int i=0;i<4;i++)
{
    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                System.out.println("线程"+Thread.currentThread().getId()+"开始执行");
                Thread.sleep(2000);
                System.out.println("线程"+Thread.currentThread().getId()+"执行结束");
                barrier.await();
            }catch (Exception ex)
            {
                System.out.println(ex);
            }
        }
    }).start();
}
new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            barrier.await();
            System.out.println("等待线程开始执行");
            Thread.sleep(2000);
            System.out.println("等待线程执行结束");
        }catch (Exception ex)
        {
            System.out.println(ex);
        }

    }
}).start();

CyclicBarrier的作用是等待所有的线程（按照初始化的时候给的线程数，这里是5个）都await后，再集中让所有的线程继续。

8.Condition方法，这个和waite/notifyAll是一样的，前者本身就是后者的优化，详细信息可以看我的另一篇博客https://blog.csdn.net/dap769815768/article/details/96720712

在这个问题上，具体的实现思路二者是完全一致的，加一个标记量，当所有的线程都云心结束了，调用Condition的signalAll方法让等待线程执行。具体的代码这里就不贴了。

returnTrue999
关注
  • 11
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java 等待线程池结束_等待线程池中任务执行完毕做优雅关闭
weixin_42519170的博客
03-05 4075
背景在Java开发中，如果涉及多线程，会经常使用到线程池，本期不额外讲述线程池本身相关的东西。考虑一种场景，如果我们提交给线程池的任务都相对比较耗时，而在任务启动运行后，如果后续有需求的变更，要重新部署业务。这时，需要关闭当前的执行实例或者重启，如果直接kill实例而任务又包含多个复杂的逻辑，可能导致一些非预期的后果。因此，类似情况下，需要等线程池中已有任务尽量执行完毕，来避免带来意料以外的问题。...
java怎么使用ThreadPoolTaskExecutor同时执行多个任务然后阻塞等待所有结果返回
m0_65659549的博客
04-17 1356
是Spring框架提供的一个线程池执行器，它允许你并发地执行多个任务，并且可以等待所有任务完成。实例，指定线程池的相关参数，如核心线程数、最大线程数、工作队列容量等。方法来优雅地关闭线程池，释放资源。方法是一个阻塞调用，它会等待任务完成。如果任务执行过程中抛出异常，方法会等待所有任务完成，并打印出每个任务的结果。，然后创建了两个模拟任务，并将它们作为。，但这可能会导致正在执行的任务被中断。方法来执行任务，并收集每个任务返回的。此外，不要忘记在不再需要线程池时调用。方法会将异常传递出来，你需要在调用。
SpringBoot2.x+Spring5+Mybits3.x后期使用vue前端构建前后端分离-13 定时任务和异步任务
qq_41525746的博客
11-09 408
什么是定时任务和常见定时任务区别 什么是定时任务，使用场景 某个时间定时处理某个任务 发邮件、短信等 消息提醒 订单通知 统计报表系统 --每天的访问的量订单等 .... 常见定时任务 Java自带的java.util.Timer类配置比较麻烦，时间延后问题 Quartz框架: 配置更简单,xml或者注解适合分布式或者大型调度作业 SpringBoot框架自带 SpringBoot使用注解方式开启定时任务 启动类里面 @EnableScheduling开启定时任务，定时自动扫描 定时
Java中如何确保在多线程情况下，所有线程都完成再继续执行任务
最新发布
hcgeng的专栏
06-02 1393
在以上示例代码中，当每个 SQL 查询任务执行完毕后都将 CountDownLatch 计数器减 1，当计数器减为 0 时，主线程的 await() 方法返回，程序继续执行后面的逻辑，汇总所有 SQL 查询结果并进行处理。在主线程中，调用 CountDownLatch 的 await() 方法在所有 SQL 查询任务执行完成前阻塞线程，直到计数器减为 0 时，所有任务都已经执行完成可以继续往下执行，此时可以对查询结果进行汇总处理。一个简化的序列图，展示了线程池中的任务是如何执行的。参数表示超时时间的单位。
java线程池开发的时候如何让主线程等待子线程执行结束后结束
别人笑我太疯癫，我笑他人看不穿。
01-02 3780
我们在直接使用Thread线程类的时候可以用join方法解决主线程等待子线程执行完毕的需求，但是在实际开发中我们用的大多是线程池，没有join方法给我们调用。这种情况JAVA提供了两种解决方法。
几种等待多线程任务执行完毕的方法
MayMatrix 的博客
09-25 6605
CountDownLatch和Cyclicbarrier概念、区别及原理 1、概念   CountDownLatch:具有计数器的功能，等待其他线程执行完毕，主线程在继续执行，用于监听某些初始化操作，并且线程进行阻塞，等初始化执行完毕后，通知主线程继续工作执行。值得注意的是CountDownLatch计数的次数一定要与构造器传入的数字一致，比如构造器传入的是3，则countDown()一定要执行3次，否则线程将一直阻塞。CountDownLatch通常用来控制线程等待，它可以让线程等待倒计时结束，.
Java多线程如何保证线程池里的线程都执行完毕
bernardGao94的博客
10-15 2064
背景： 项目中为了提高性能常常会引入多线程，当我们使用线程池时有时要满足“当线程池里的线程都执行完毕后才能进行下一步”这种业务场景，例如：当多线程操作一个文件时要保证所有线程都运行完毕才能保证文件的完整；当用多线程给一个对象的多个属性进行赋值时要保证线程都运行完毕才将此对象返回，否则就会出现对象属性不全。 实现方式： 1、使用isTerminated方法 2、使用CountDownLatch 3...
等待多个线程执行完成后再运行的几种方式
dream_xin2013的专栏
11-03 2889
介绍在使用多线程过程中，需要等待多个线程执行完后再执行主线程的几种实现方式，提升系统性能
java主线程等待子线程池执行完再执行
weixin_43873239的博客
11-20 398
是 Java 中用于等待线程池中的所有任务执行完毕的方法。这个方法通常用于在程序结束前确保所有任务都已经完成，例如在服务器关闭之前。来阻塞当前线程，直到所有任务完成执行，或者超时，或者当前线程被中断。方法来等待线程池中的所有任务执行完毕。以下是一个简单的示例。如果等待过程中当前线程被中断，它会抛出。如果线程池在指定的时间内关闭，或者调用。来创建一个线程池，并使用。在Java中，你可以使用。如果超时期限到达，返回。
Java线程学习和总结
03-16
本文档（"Java线程学习和总结.htm"）可能包含了更多关于线程的实例、源码分析和常见问题解决方案，你可以通过阅读来进一步加深对Java线程的理解。同时，"Java线程学习和总结.files"目录下的文件可能是与文章相关的...
Java分布式系统高并发解决方案.docx
05-16
在Java分布式系统中，面对高并发访问的问题，开发者需要掌握一系列的解决方案以保证系统的稳定性和高效性。本文主要讨论的是并发和同步的概念以及处理并发和同步的方法，特别是通过锁机制来管理资源的访问。 首先，...
Java主线程等待子线程执行完毕
05-24
非常实用不解释，用了才知道 个人收藏的一部分资料将陆续给大家上传
Java多线程--等待所有子线程执行完的五种方法.docx
09-14
Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法
Java 多线程学习总结6
03-13
10. **线程安全问题与解决方案** - **原子性**：使用synchronized、Lock或Atomic类保证操作的不可分割性。 - **可见性**：使用volatile保证多线程间共享变量的可见性。 - **有序性**：使用volatile、synchronized...
java,多线程实验.zip
06-16
总结，Java多线程实验涉及的内容广泛，包括线程的创建与管理、同步与通信、线程池的使用、线程调度策略以及并发编程中常见的问题与解决方案。通过编写和调试多线程程序，可以更好地理解这些概念并提升在实际项目中的...
Java线程超时监控
07-18
在Java编程中，多线程是并发执行任务的重要方式，然而在实际应用中，我们可能会遇到某些线程执行时间过长...在实际开发中，应根据项目需求选择最适合的解决方案，并确保在超时处理中考虑到资源的释放和异常的妥善处理。
Java多线程之以7种方式让主线程等待子线程结束
weixin_33858336的博客
06-10 819
记一次主线程等待子线程结束的多种方法的学习 在学习多线程时，最开始遇到的问题其实是“计算子线程运行时间”，写到最后发现本文和标题更为符合，但是仍然基于问题：“在主线程中获取子线程的运行时间”。 while循环 对于“主线程如何获取子线程总运行时间”的问题，最开始想到的是使用while循环进行轮询： Thread t = new Thread(() -> { //子线程进行字符串连接...
介绍几种等待多线程任务执行完毕的方法
liuqinhou的博客
10-12 2483
java 多线程
java多线程同时运行，等待任一线程完成后结束所有线程
06-07
你可以使用 Java 中的 CountDownLatch 类来实现这个功能。CountDownLatch 是一个同步工具，用于在一个或多个线程等待一组事件发生时等待其他线程。 具体实现方式如下： 1. 创建 CountDownLatch 对象，并将计数器初始化为线程数。 2. 每个线程执行完任务后，调用 CountDownLatch 的 countDown() 方法来减少计数器的值。 3. 在主线程中调用 CountDownLatch 的 await() 方法等待计数器为 0。 4. 当计数器为 0 时，主线程继续执行，结束所有线程。 示例代码如下： ```java import java.util.concurrent.CountDownLatch; public class MultiThreadDemo { public static void main(String[] args) throws InterruptedException { int threadCount = 10; CountDownLatch latch = new CountDownLatch(threadCount); for (int i = 0; i < threadCount; i++) { new Thread(new Task(latch)).start(); } latch.await(); System.out.println("所有线程执行完成"); } static class Task implements Runnable { private CountDownLatch latch; public Task(CountDownLatch latch) { this.latch = latch; } @Override public void run() { // 执行任务 System.out.println(Thread.currentThread().getName() + "执行任务"); latch.countDown(); } } } ``` 在上面的示例代码中，创建了 10 个线程并启动，每个线程执行完任务后，调用 CountDownLatch 的 countDown() 方法，计数器减 1，当计数器为 0 时，主线程从 await() 方法中返回，输出 "所有线程执行完成"。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值