Java8 CompletableFuture使用

最新推荐文章于 2024-06-07 23:22:32 发布
最新推荐文章于 2024-06-07 23:22:32 发布
阅读量1k 收藏 2
点赞数
分类专栏： 并发 java基础 文章标签： CompletableFuture Future Callable Runnable
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xktxoo/article/details/95100563
版权
一、Future接口
  • 1.1 Runnable与Callable

Runnable接口源自JDK1.1，它只有一个run()方法，该方法没有返回结果：

public interface Runnable {
    public abstract void run();
}

Callable接口是JDK1.5中添加，只有一个call()方法，该方法支持结果返回且可以抛出异常：

public interface Callable<V> {
    V call() throws Exception;
}

无论是Runnalble还是Callable任务实例，直接调用时不会新开启子线程，是在主线程中运行。如果要在子线程中运行这些任务，需要将任务提交到Thread实例或线程池执行。值得注意的是通过Thread实例执行Callable任务，Thread没有接受Callable入参的构造函数，因此，不能直接构造Callable任务的Thread实例。可以通过构建FutureTask任务将Callable任务提供到Thread实例执行，因为FutureTask实现了Runnable接口，且其构造函数入参支持Callable类型。

	@Test
    public void testRunable() throws Exception {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000L);
                    System.out.println(Thread.currentThread().getName());
                } catch (InterruptedException e) {
                }
            }
        };

        Callable<Integer> c = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                try {
                    Thread.sleep(1000L);
                    System.out.println(Thread.currentThread().getName());
                } catch (InterruptedException e) {
                }
                return ThreadLocalRandom.current().nextInt(100);
            }
        };

        r.run();
        System.out.println(c.call());

        Thread t = new Thread(r);
        t.start();
        t.join(); // 不阻塞时，如果主线程比子线程先完成，则子线程中任务不会完整执行

        FutureTask<Integer> f = new FutureTask<>(c);
        Thread t2 = new Thread(f);
        t2.start();
        t2.join(); // 不阻塞时，如果主线程比子线程先完成，则子线程中任务不会完整执行
        System.out.println(f.get());

        ExecutorService executorService = Executors.newFixedThreadPool(1);
        executorService.submit(r);
        Future<Integer> future = executorService.submit(c);
        System.out.println(future.get()); // 不阻塞时，如果主线程比子线程先完成，则子线程中任务不会完整执行
    }
---
main
main
62
Thread-0
Thread-1
6
pool-1-thread-1
pool-1-thread-1
36

注意：通过junit对以上代码进行测试时，如果主线程比子线程先执行完成，则主线程执行完成后会程序会退出，意味着没有完成的子线程任务不会再继续执行。因此，如果需要子线程完整执行，则需要阻塞主线程。

  • 1.2 Future接口

Future接口也是在JDK1.5中添加的，用于描述一个异步Callable任务的计算结果，如下所示。Future接口一共有5个方法：通过cancel()方法停止任务；通过isCanceld()方法判断任务是否被停止；通过isDone()方法检查任务是否完成；提供了两个重载版本的get方法，用于阻塞调用线程，直到任务完成或超时。

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);

    boolean isCancelled();

    boolean isDone();

    V get() throws InterruptedException, ExecutionException;

    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

Future只能通过阻塞或轮训的方式获取任务结果，阻塞违背异步变成的初衷，轮训的方式又耗费了CPU资源，通过Future获取异步任务结果的示里如下：

    @Test
    public void testFuture() throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        List<Future<Integer>> futures = new ArrayList<>();
        List<Integer> results = new ArrayList<>();
        for(int i=0; i <= 3; i++) {
            final int j = i;
            Future<Integer> future = executorService.submit(() -> {
                try {
                    Thread.sleep(j * 100L);
                } catch (InterruptedException e) {
                }
                return ThreadLocalRandom.current().nextInt(100);
            });
            futures.add(future);
        }
        for(Future<Integer> future : futures) {
            while(true) {
                if(future.isDone() && !future.isCancelled()) {
                    results.add(future.get());
                    break;
                }
            }
        }
        System.out.println(results);
    }
二、CompletableFuture

JDK8中添加了ComletableFuture类，它实现了Future接口和CompletionStage接口，其中CompletionStage可以看做是一个异步任务执行过程的抽象，如下。它简化了异步变成的复杂性，并提供了函数式变成的能力。ComletableFuture提供了同步和异步的执行方式，其异步方式又支持外部声明的线程池，如果不提供外部线程池，则异步时默认使用ForkJoinPool.commonPool()。

public class CompletableFuture<T> implements Future<T>, CompletionStage<T> {
...
}

CompletableFuture实现了Future接口，因此，也可以通过以前的方式阻塞或轮训获取结果：

// 同Future
public T get() throws InterruptedException, ExecutionException {
...
}

// 同Future
public T get(long timeout, TimeUnit unit)throws InterruptedException, ExecutionException, TimeoutException {
...
}

// 返回执行结果或抛出一个unchecked异常
public T join() {
...
}

// 如果执行结束则返回执行结果，否则返回valueIfAbsent
public T getNow(T valueIfAbsent) {
...
}

CompetableFuture.completedFuture是一个静态辅助类，用于返回一个计算好的CompletableFuture，示例：

    @Test
    public void testComletedFuture() throws InterruptedException, ExecutionException {
        CompletableFuture<String> future = CompletableFuture.completedFuture("result");
        System.out.println(future.get());
    }
---
result

通过以下四个静态方法为异步执行代码创建CompletableFuture对象：

// 接受Runnable任务，返回结果为空
public static CompletableFuture<Void> runAsync(Runnable runnable) {
...
}

// 接受Runnable任务，返回结果为空，指定线程池
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor) {
...
}

// 接受Supplier对象，可指定返回类型
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
...
}

// 接受Supplier对象，可指定返回类型，指定线程池
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor) {
...
}

CompletableFuture任务执行示例如下，可指定执行线程池，如不指定则使用ForkJoinPool.commonPool()。

    @Test
    public void testCreateSyncTask() throws InterruptedException, ExecutionException {
        CompletableFuture<String> f1 = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            return "supplyAsync result";
        });
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        CompletableFuture<Void> f2 = CompletableFuture.runAsync(() -> {
            System.out.println(Thread.currentThread().getName());
        }, executorService);
        System.out.println(f1.get());
    }
---
ForkJoinPool.commonPool-worker-1
supplyAsync result
pool-1-thread-1

Future和CompletableFuture提供的get()方法是阻塞的，为了获取任务结果同时不阻塞当前线程，可使用CompletionStage提供的方法实现任务异步处理，有以下4中处理方式：

// 上游任务完成后在当前主线程中同步执行处理，向下传递上游处理结果或异常
public CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action) {
...
}

// 上游任务完成后在当前子线程中异步执行处理，向下传递上游处理结果或异常
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action) {
...
}

// 上游任务完成后在当前主线程中同步执行处理，指定线程池，向下传递上游处理结果或异常
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action, Executor executor) {
...
}

// 上游任务异常时处理，在主线程中完成
public CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn) {
...
}

示例代码如下：

    @Test
    public void testWhenComplete() throws InterruptedException, ExecutionException {
        CompletableFuture<String> f1 = CompletableFuture.supplyAsync(() -> {
            return "test";
        }).whenCompleteAsync((result, exception) -> {
            if (result != null) {
                System.out.println(result);
            } else {
                exception.printStackTrace();
            }
        });
        System.out.println(f1.get());

        CompletableFuture<String> f2 = CompletableFuture.supplyAsync(() -> {
            int i = 1 / 0;
            return "test";
        }).exceptionally((e) -> {
            e.printStackTrace();
            return "error";
        });
        System.out.println(f2.get());
    }
---
test
error
java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
...

whenComplete方法入参是BiConsumer，它是一个纯消费者函数，不会修改返回值及其类型。下面一组接口除了whenComplete的功能外，同时具备转换结果的功能，通过参数BiFunction实现：

public <U> CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn) {
...
}

public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn) {
...
}

public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn, Executor executor) {
...
}

示例代码如下：

    @Test
    public void testHandle() throws InterruptedException, ExecutionException {
        CompletableFuture<String> f1 = CompletableFuture.supplyAsync(() -> {
            return "100";
        });
        CompletableFuture<Integer> f2 = f1.handleAsync((result, exception) -> {
            if(exception != null) {
                exception.printStackTrace();
            }
            return Integer.parseInt(result) * 10;
        });
        System.out.println(f2.get());
    }
---
1000

handle方法依然保留了对异常请款的处理，在BiFunction中指定其第二个参数类型是Throwble。接下来一组方法thenApply与handle类似，也可以对上游结果进行转换，同时忽略对异常情况的处理。

public <U> CompletableFuture<U> thenApplyFunction<? super T,? extends U> fn){
...
}

public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn) {
...
}

public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn, Executor executor) {
...
}

示例代码：

	@Test
    public void testThenApply() throws InterruptedException, ExecutionException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            //int i= 1/0;
            return "100";
        });
        CompletableFuture<Integer> f = future.thenApply(t -> Integer.parseInt(t) * 10).thenApply(t -> t * 10);
        System.out.println(f.get());
    }
---
10000

上述方法处理完成后，都会返回计算结果，CompletableFuture还提供了一组处理方法，只对上游处理结果进行消费，且没有返回，如果上游发生异常，则不执行该方法；同时，CompletableFuture还提供了一组加强版方法，提供两个CompletableFuture任务都完成或完成一个时执行的方法。

public CompletableFuture<Void> thenAccept(Consumer<? super T> action) {
...
}

public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action) {
...
}

public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action,Executor executor) {
...
}

public <U> CompletableFuture<Void> thenAcceptBoth(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action) {
...
}

public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action) {
...
}

public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action, Executor executor) {
...
}
public CompletableFuture<Void> acceptEither(CompletionStage<? extends T> other, Consumer<? super T> action) {
...
}

public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action) {
...
}

public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action,Executor executor) {
...
}

示例代码：

    @Test
    public void testThenAccept() throws InterruptedException, ExecutionException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            int i = 1/0;
            return "1";
        });
        CompletableFuture<Void> f = future.thenAccept(t -> {
            System.out.println(t);
        });
    }
---

上述方法都依赖上游处理的结果，CompletableFuture还提供了一组方法，不依赖上游的结果，如下

public CompletableFuture<Void> thenRun(Runnable action) {
...
}

public CompletableFuture<Void> thenRunAsync(Runnable action) {
...
}

public CompletableFuture<Void> thenRunAsync(Runnable action,Executor executor) {
...
}

示例代码：

    @Test
    public void testThenRun() throws InterruptedException, ExecutionException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            return "result";
        });
        CompletableFuture<Void> f = future.thenRunAsync(() -> {
            System.out.println("future then run");
        });
    }
---
future then run

thenCompose这组方法与thenApply类似，都可以将上游执行结果作为本stage入参继续计算，并转换返回类型，不同的是thenCompose在一个新CompletableFuture对象执行计算。

public <U> CompletableFuture<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> fn) {
...
}

public <U> CompletableFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn) {
...
}

public <U> CompletableFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn,Executor executor) {
...
}

示例代码：

    @Test
    public void testThenCompose() throws InterruptedException, ExecutionException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            return "10";
        });
        CompletableFuture<Integer> f = future.thenCompose(v -> {
            return CompletableFuture.supplyAsync(() -> {
               return Integer.parseInt(v) * 100;
            });
        });
        System.out.println(f.get());
    }
---
1000

thenCombine这组方法与thenAccepBoth类似，不同的是thenCombine有返回值：

public <U,V> CompletableFuture<V> thenCombine(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn) {
...
}

public <U,V> CompletableFuture<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn) {
...
}

public <U,V> CompletableFuture<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn, Executor executor) {
...
}

示例代码：

    @Test
    public void testThenCombine() throws InterruptedException, ExecutionException {
        CompletableFuture<String> f1 = CompletableFuture.supplyAsync(() -> {
            return "abc";
        });
        CompletableFuture<Integer> f2 = CompletableFuture.supplyAsync(() -> {
            return 123;
        });
        CompletableFuture<String> f3 = f1.thenCombine(f2, (m,n) -> {
            return m + " is " + n;
        });
        System.out.println(f3.get());
    }
---
abc is 123

最后两个方法用于组合多个CompletableFuture，allOf方法是当所有CompletableFuture执行完成后执行计算，anyOf方法是任意一个CompletableFuture执行完成后执行计算。

public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs) {
...
}

public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs) {
...
}

示例代码：

    @Test
    public void testAllof() throws InterruptedException, ExecutionException {
        List<CompletableFuture<Integer>> list = new ArrayList<>();
        Random random = new Random();
        for (int i=1; i < 10; i++) {
            list.add(CompletableFuture.supplyAsync(() -> {
                return random.nextInt(100);
            }));
        }
        CompletableFuture<Void> fn = CompletableFuture.allOf(list.toArray(new CompletableFuture[list.size()]));
        CompletableFuture<List<Integer>> fr = fn.thenApply(v -> {
            return list.stream().map(CompletableFuture::join).collect(Collectors.toList()); 
        });
        System.out.println(fr.get());
    }
---
[3, 97, 11, 93, 22, 77, 68, 26, 89]
参考
Jerry的技术博客
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
异步编程利器：CompletableFuture详解 ｜Java 开发实战
阿星君
06-19 1034
06日阅读 1005 关注 前言 文正在参加「Java主题月 - Java 开发实战」， 我们异步执行一个任务时，一般是用线程池Executor去创建。如果不需要有返回值， 任务实现Runnable接口；如果需要有返回值，任务实现Callable接口，调用Executor的submit方法，再使用Future获取即可。如果多个线程存在依赖组合的话，我们怎么处理呢？可使用同步组件CountDownLatch、CyclicBarrier等，但是比较麻烦。其实有简单的方法，就是用Compele..
CompletableFuture基本使用
工作记录
04-02 3589
CompletableFuture是什么 CompletableFuture是Java8中提供的Future的扩展功能，帮助我们简化异步编程的复杂性，引入函数式编程，通过回调的方式处理计算结果，也提供了转换和组合的方法。 它可能代表一个明确完成的Future，也有可能代表一个完成阶段（ CompletionStage ），它支持在计算完成以后触发一些函数或执行某些动作。 它实现了Future和CompletionStage接口 借助CompletionStage的方法可以实现链式调用 一个Comp
异步编程CompeletableFuture方法详解(应对各种场景)
ggjklncffd的博客
03-26 643
CompeletableFuture是Java 8中用于异步编程的一个新特性，它可以帮助我们更方便地处理异步任务的结果，避免了传统的回调地狱的问题。
CompletableFuture详解
qq_40276626的博客
08-27 4003
在阅读这篇文章之前，需要一点lambda知识，如果不太清楚的话，可以看我之前写的Java8中lambda详解 CompletableFuture的出现原因 我们上篇文章说了Future和FutureTask。但是Future有一个缺点，调用线程需要使用future.get()来获取调用结果，这个方法是阻塞的，也就说调用线程会被阻塞。 而CompeletableFuture提供了回调方法来解决这一问题。当任务执行完之后，会通知调用线程来执行回调方法。而在调用回调方法之前，调用线程可以执行其他任务，是非阻塞的。
java 8 新特性CompletableFuture使用
最新发布
weixin_41463944的博客
06-07 363
java 8 新特性CompletableFuture使用
高并发场景实战: 线程池,countDownLatch,CompletableFuture混合使用
qq_37805943的博客
08-14 2397
写在前面: 希望大家从一开始就跟着敲, 收获一定是满满的, 末尾会留公众号,想一起努力的小朋友可以一起加入, 由兴趣可一起维护我们共同的公众号。 1:项目搭建 需要引入的maven //提供线程池,TransmittableThreadLocal两个工具类 <dependency> <groupId>com.alibaba</groupId> <artifactId>transmittable-threa.
Java8 CompletableFuture底层实现及使用详解
程序员野蛮成长
07-14 871
该方法的区别在于，它将任务串联起来，可以实现多个异步操作的链式调用。然后，通过thenApply方法将该CompletableFuture对象转换为一个新的CompletableFuture对象，用于异步执行一个返回整数类型的任务，转换函数是将字符串长度作为结果返回。thenCompose方法接收一个Function类型的参数，该函数用于将一个CompletableFuture对象的结果作为下一个CompletableFuture对象的输入，并返回一个新的CompletableFuture对象。
java8之CompletableFuture
weixin_44504392的博客
08-29 566
5分钟带你深入浅出CompletableFuture实用教程。
Java8 CompletableFuture详解
09-04
Java 8 的 `CompletableFuture` 是对传统 `Future` 接口的重要扩展，它引入了丰富的功能，使得异步编程和事件驱动模型更加便捷。`CompletableFuture` 不仅集成了 Guava 的 `ListenableFuture` 和 `SettableFuture` ...
CompletableFutureExamples:使用Java的CompletableFuture进行异步编程的示例
05-09
Java 8引入了`CompletableFuture`类，为开发者提供了一种强大且灵活的方式来处理异步计算。`CompletableFuture`是Java并发API的一部分，它构建于`Future`接口之上，但提供了更丰富的功能，包括链式调用、组合多个...
Java并发 CompletableFuture异步编程的实现
08-25
Java并发 CompletableFuture异步编程的实现 在 Java 中，CompletableFuture 是一种异步编程的实现方式，它可以帮助开发者轻松地实现异步操作。CompletableFuture 的核心优势在于它可以将串行操作变成并行操作，从而...
Java8新的异步编程方式CompletableFuture实现
08-26
Java 8 引入了一种新的异步编程工具——`CompletableFuture`，它极大地扩展了传统的`Future`接口，提供了一种更为强大的方式来处理异步任务和组合多个异步操作。`CompletableFuture`旨在解决`Future`模式的一些固有...
asyncjerseygrizzly:JAX-RS 2 Async (Jersey) 和 Java 8 CompletableFuture 的实验
06-23
异步泽西灰熊实验JAX-RS 2 Async (Jersey) 和 Java 8 CompletableFuture 的实验基于来自： : 教程这是一个 Maven 项目。 需要 JDK 8 才能使用 CompletableFuture 和其他 Java 8 功能。
CompletableFuture 详解（一）：基本概念及用法
qq_43985303的博客
12-28 1200
CompletableFuture是java.util.concurrent库在java 8中新增的主要工具，同传统的Future相比，其支持流式计算、函数式编程、完成通知、自定义异常处理等很多新的特性。由于函数式编程在java中越来越多的被使用到，熟练掌握CompletableFuture，对于更好的使用java 8后的主要新特性很重要。简单起见，本文使用的CompletableFuture版本为java 8（java 11的CompletableFuture新增了一些方法）。
java future专题 3-1 CompletableFuture和Listenablefuture的转换
xocupid的博客
06-30 1089
llistenablefuture和CompletableFuture的比较：ListenableFuture和CompletableFuture简单小结_走在前往架构师的路上-CSDN博客那些年我们追过的异步骚操作：ListenableFuture、CompletableFuture、RxJava(Observable)_布道-CSDN博客https://github.com/AsyncHttpClient/async-http-client ning捐赠后加入了CompletableFuture在一些情
基于 Javaassist 和 Java agent 实现零侵入的 CompletabelFuture 线程切换时 ThreadLocal 继承
qq_41699954的博客
05-14 732
基于上述分析，着重介绍本文的解决方案：Javaassist 增强方法；Java assist 可以实现在类加载到 JVM 之前对类的字节码进行修改、增强，就可以很好的解决这个问题；（这种对系统核心类库进行字节码修改的操作好像不是特别推荐，此处只是给出这种思路的具体实现，不考虑工程上的合理性）要实现无侵入，还要使用 Java agent，先简单理解为可以在 main 方法执行前执行一些操作，实现对类加载到 JVM 之前，先对其字节码进行修改，这样业务上使用他的一些方法时就和以前一样，实现了零侵入的方法增强。
【JAVA8】CompletableFuture使用详解
热门推荐
胖虎儿的博客
08-22 1万+
CompletableFuture！让你的代码免受阻塞之苦！ 灵活的使用`CompletableFuture`可以让我们感受java8的异步编程之美!
CompletableFuture使用
小布1994的博客
06-29 175
CompletableFuture 使用详解
简单使用ThreadLocal、FunctionalInterface、CompletableFuture
qq_34922830的博客
06-24 488
数据迁移、涉及上万条数据，使用Job利用多线程处理。 ThreadLocal的引入不必有多少条数据处理New 多少个Req对象 CompletableFuture 还使用以下策略实现接口CompletionStage，then***方法 可将一个任务产分成多份。代码中。将下载-》上传-》更新 拆分成了三部分。方便日志的记录 使用了CompletionStage handleAsync（）方法对以上三步进行异常总结 为了记录成功、失败、异常的次数使用了atomic的LongAdder...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值