Java基础篇（七）

最新推荐文章于 2024-08-18 21:36:31 发布
最新推荐文章于 2024-08-18 21:36:31 发布
阅读量48 收藏
点赞数
文章标签： java jvm 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45802566/article/details/130021720
版权

1.进程

是一个独立运行的应用程序

​ 比如电脑软件，启动之后，就是一个进程，需要系统进行的分配，可以获取当前系统内存，网卡，显卡等。

​ 1.独立性

​ 各个进程之间是互相独立的，互不影响的。

​ 2.互斥性

​ 每个应用程序(软件) 系统分配一个独立的端口号

​ 写代码 Demo1 里面 main主函数 Demo1可以看成一个应用程序 就是一个进程

2.线程

进程是由至少一个或者多个线程组成的。

线程是进程最小的基本单位。

特性:
1.抢占式运行【重要】
	给程序 分配CPU，按照时间片来执行，单位时间片抢占式执行的。随机抢占的

2.资源共享
	同一个进程，有多个线程，这个多个线程是可以共享同一个数据的
	Java程序：Demo1可以看成一个进程，一个Java程序中有两个线程:
		1.main 主线程
		2.垃圾回收的线程

面试题：进程和线程的区别

1、调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位。
2、并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可以并发执行。
3、拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程
的资源。
4、系统开销：在创建或撤销进程的时候，由于系统都要为之分配和回收资源，导致系统的明显
大于创建或撤销线程时的开销。但进程有独立的地址空间，进程崩溃后，在保护模式下不会对其
他的进程产生影响，而线程只是一个进程中的不同的执行路径。线程有自己的堆栈和局部变量，
但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多
线程的程序健壮，但是在进程切换时，耗费的资源较大，效率要差些。

3.并行和并发

并行：真正的同时执行

并发：同时发生，轮流交替执行

4.创建线程的两种方式

Java虚拟机允许应用程序同时执行多个执行线程。

创建线程的第一种：

​ 创建一个新的执行线程有两种方法。一个是将一个类声明为Thread的子类（继承Thread）。这个子类应该重写run方法，然后可以分配并启动子类的实例。

package com.qf.Day23;

class MyThread1 extends Thread {
    //重写run方法
    @Override
    public void run() {
        //这个线程中打印10次的MyThread1线程:
        for (int i = 0; i < 9; i++) {
            System.out.println("线程：" + i);
        }
    }
}

public class Demo4 {
    public static void main(String[] args) {
        MyThread1 myThread1 = new MyThread1();
        //启动线程
        new Thread(myThread1).start();
        for (int i = 0; i < 100; i++) {
            System.out.println("main主线程" + i);
        }
    }
}

练习：新建两个线程，一个县城打印99乘法表，另一个线程打印直角三角形

package com.qf.a_thread;

class MyThread3 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i < 10; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + i*j + "\t");
            }
            System.out.println();
        }
    }
}
class MyThread4 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i < 10 ; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        new MyThread3().start();
        new MyThread4().start();
    }
}

第二种创建方式:

另一种方法来创建一个线程是声明实现类Runnable接口。 那个类然后实现了run方法。 然后可以分配类的实例，在创建Thread时作为参数传递，并启动。

package com.qf.b_thread;

class MyThread1 implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("MyThread1:" + i);
        }
    }
}
class MyThread2 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("MyThread2:" + i);
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        MyThread1 myThread1 = new MyThread1();
        MyThread2 myThread2 = new MyThread2();
        //在创建Thread时作为参数传递并启动。
        new Thread(myThread1).start();
        new Thread(myThread2).start();
    }
}

练习:新建两个线程，一个线程打印99乘法表，另外一个线程打印直接三角形

package com.qf.b_thread;


class MyThread3 implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i < 10 ; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}
class MyThread4 implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i < 10; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + i*j + "\t");
            }
            System.out.println();
        }
    }
}
public class Demo3 {
    public static void main(String[] args) {
        //然后可以分配类的实例，在创建Thread时作为参数传递，并启动。
        new Thread(new MyThread3()).start();
        new Thread(new MyThread4()).start();
    }
}

5.死锁

开发中禁止出现死锁

面试题：

​ 应用场景：并发场景，多个线程。线程之间在共享数据的时候是互不相让的

线程加锁是为了线程安全

死锁是一种状态，当两个线程互相持有对象所需要的资源的时候，这两个线程又都不主动释放资源。

就会导致死锁。代码无法正常执行。这两个线程就会僵持住。

package com.qf.review;

class DeadLock implements Runnable {//实现Runnable接口
    private boolean flag;//标记
    private Object obj1;//对象1
    private Object obj2;//对象2

    public DeadLock(boolean flag, Object obj1, Object obj2) {//构造函数
        this.flag = flag;
        this.obj1 = obj1;
        this.obj2 = obj2;
    }
    //重写run方法
    @Override
    public void run() {
        if (flag) {//如果flag = true 让线程1执行这个if语句里面的代码
            synchronized (obj1) {
                System.out.println(Thread.currentThread().getName() + "拿到了obj1资源");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1执行了");
                synchronized (obj2) {//锁obj2的前提是先有obj2资源
                    //想用obj2这个资源，但是下面未释放obj1，所以就停了，导致obj2也未释放掉
                    System.out.println(Thread.currentThread().getName() + "拿到obj2资源");
                }
            }
        }
        if (!flag) {//如果flag=false 线程2 执行这个if语句里面的代码
            synchronized (obj2) {
                System.out.println(Thread.currentThread().getName() + "拿到了obj2资源");
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程2执行了");
                synchronized (obj1) {//不自动释放
                    //想用obj1这个资源，但是上面未释放obj2，所以就停了，导致obj1也未释放掉
                    System.out.println(Thread.currentThread().getName() + "拿到obj1资源");
                }
            }
        }
    }
}

public class Review20 {
    public static void main(String[] args) {
        Object obj1 = new Object();
        Object obj2 = new Object();
        DeadLock deadLock1 = new DeadLock(true, obj1, obj2);
        new Thread(deadLock1, "线程1").start();
        DeadLock deadLock2 = new DeadLock(false, obj1, obj2);
        new Thread(deadLock2, "线程1").start();
    }
}

6.Object类下面的和线程相关的方法

public final void wait(){
		throws InterruptedException
}

导致当前线程等待，直到另一个线程调用该对象notify()方法或者notifyAll()方法。

总结：至少两个线程，对象.wait()，那么当前线程就会阻塞。阻塞就是这个线程暂时不执行了。如何让这个线程继续执行下去呢？再开另外一个线程，对象.notify()去唤醒另外一个线程！！！

wait1线程正在等待中....
唤醒线程已经执行
wait1线程被唤醒!!!Line45行的
我是修改之后的message对象
wait2线程正在等待中....

package com.qf.review;
class Message{//先创建类，再创建对象，再调用wait方法
    private String message;

    public Message(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}
//线程类
class WaitThread implements Runnable {
    private Message message;//使用message这个对象，调用wait方法  message.wait()

    public WaitThread(Message message) {//构造方法
        this.message = message;
    }

    //等待线程抢到了
    //等待线程睡了5秒  然后唤醒线程执行。  synchronized (message)
    //message  对象从等待池中国去取的，结果发现没有  阻塞
    //回到等待线程睡醒了以后开始   wait等待
    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println(name + "正在等待中....");

        synchronized (message) {
            try {

                //当调用wait方法的时候，synchronized会自动释放锁，（并将对象放到等待池中），让唤醒线程锁来操作这个对象,然后message对象会放到等待池中
                //
                message.wait();//代码走到这一步 当前线程会等待！！！直到被唤醒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name + "被唤醒!!!Line45行的");
            System.out.println(message.getMessage());
        }
    }
}
    //唤醒线程
    class NotifyThread implements Runnable {
        private Message message;

        public NotifyThread(Message message ) {
            this.message = message;
        }
        @Override public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("唤醒线程已经执行");
            synchronized (message) {
                message.setMessage("我是修改之后的message对象");
                //message.notify();
                message.notifyAll();
            }
        }
    }
public class Review21 {
    public static void main(String[] args) {
        Message message = new Message("我是message对象");
        WaitThread waitThread = new WaitThread(message);
        WaitThread waitThread1 = new WaitThread(message);
        NotifyThread notifyThread = new NotifyThread(message);
        new Thread(waitThread1, "wait2线程").start();
        new Thread(waitThread, "wait1线程").start();
        new Thread(notifyThread, "notify线程").start();
    }
}

总结：
新建两个线程：
	一个是等待线程：
		等待线程中代码从上往下执行，但是使用object.wait()方法以后，咱们当前的线程就等待了，到wait之后代码暂时不会往下执行了，需要借助于另外一个线程进行唤醒。
	一个是唤醒线程：
		唤醒线程使用object.notify方法去讲等待线程中的正在等待的线程进行唤醒，让等待线程继续往下执行。
wait和notify方法，实现线程之间的通信问题。

wait2线程正在等待中....
wait1线程正在等待中....
唤醒线程已经执行
wait1线程被唤醒!!!Line45行的
我是修改之后的message对象
wait2线程被唤醒!!!Line45行的
我是修改之后的message对象

7.join方法【开发不用】

为啥join方法放在wait方法之后讲，因为join方法的底层是wait()方法

作用：让主线程等待，一直等待他的子线程执行完以后，才执行主线程

package com.qf;

//创建子线程类
class MyTh implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            String name = Thread.currentThread().getName();
            System.out.println(name + "线程执行了");
        }
    }
}

public class Demo24 {
    public static void main(String[] args) throws InterruptedException {
       /* MyTh myTh=new MyTh();
        Thread thread=new Thread(myTh);*/
        Thread thread=new Thread(new MyTh());
        thread.start();
        thread.join();//让主线程等待，一直等待他的子线程执行完以后，才执行主线程，秒数在join中是无用的
        for (int i = 0; i < 100; i++) {
            String name=Thread.currentThread().getName();
            System.out.println(name + "线程执行了");
        }
    }
}

主线程和子线程是相对而言的。

package com.qf.Day24;

class FatherTherad implements Runnable{

    @Override
    public void run() {
        //SonThread线程是在FatherTherad线程中启动的，那就意味着SonThread是FatherTherad的子线程
        Thread thread = new Thread(new SonThread());
        thread.start();
        //thread的父线程等待，先执行子线程
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 1000; i++) {//join要先进行操作
            System.out.println("父线程" + i);
        }
    }
}
class SonThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.err.println("子线程" + i);
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        //在父线程中只需要
        //互相套着调用
        new Thread(new FatherTherad()).start();
    }
}

面试题：如何控两个线程的执行顺序？

1、sleep方法使一个线程先睡会，先执行另外一个线程

2、join，让子线程先执行完，在执行父线程

3、线程池

8.生产者消费者模式

生活中的案例：

​ 卖家：汽车厂商

​ 买家：群众

​ 小明想买一个BYD汉，电车定完以后需要等待。

​ 小明告知汽车厂商我要买车，如果又，直接发货。如果没有，小明会纳入等待状态。等汽车厂商生产好以后，唤醒小明的等待线程。然后等待小明来买车。如果没有人买车。汽车会进入到等待状态。如果有人来买车，立马唤醒汽车厂商线程，让他赶紧造车。

生产者：汽车厂商

消费者：小明
在这里插入图片描述

入门案例：

package com.qf.day25;

//生产者消费者模式   Customer   Productor
//goods类，两个线程的共享资源
class Goods {//共享资源
    private String name;
    private double price;
    private boolean isProductor;//代表是否需要生产，true  生产    false  表示不需要生产

    public Goods(String name, double price, boolean isProductor) {
        this.name = name;
        this.price = price;
        this.isProductor = isProductor;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public boolean isProductor() {
        return isProductor;
    }

    public void setProductor(boolean productor) {
        isProductor = productor;
    }
}

//消费者线程
class Customer implements Runnable {
    private Goods goods;

    public Customer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        while (true) {
            //上锁
            synchronized (goods) {
                if (!goods.isProductor()) {//表示不需要生产
                    System.out.println("消费者购买的是" + goods.getName() + "价格是" + goods.getPrice());
                    //把标记变成true
                    goods.setProductor(true);
                    //唤醒生产者
                    goods.notify();
                } else {//表示的是需要生产,消费者等待
                    try {
                        goods.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

class Productor implements Runnable {
    private Goods goods;

    public Productor(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        int count = 0;
        while (true) {
            synchronized (goods) {
                if (goods.isProductor()) {//true，表示需要生产
                    //若是奇数的话就生产幻影，若是偶数的话就生产 s9
                    if (count % 2 == 0) {//偶数
                        goods.setName("幻影");
                        goods.setPrice(9.9);
                    } else {
                        goods.setName("s9");
                        goods.setPrice(8.8);
                    }
                    count++;
                    //更改标记
                    goods.setProductor(false);
                    //唤醒消费者
                    goods.notify();
                } else {//表示不需要生产
                    try {
                        goods.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

public class Demo4 {
    public static void main(String[] args) {
        Goods goods = new Goods("五菱", 6.6, false);
        Customer customer = new Customer(goods);
        Productor productor = new Productor(goods);
        new Thread(customer).start();
        new Thread(productor).start();
    }
}

goods.notify();
} else {//表示不需要生产
try {
goods.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}

public class Demo4 {
public static void main(String[] args) {
Goods goods = new Goods(“五菱”, 6.6, false);
Customer customer = new Customer(goods);
Productor productor = new Productor(goods);
new Thread(customer).start();
new Thread(productor).start();
}
}
蜗牛不会飞～
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
大厂面试突击——java基础篇
公号：一条coding
08-09 2万+
全文共11620字，我不相信你能一次看完
Java基础篇：反射机制详解
张维鹏的博客
12-03 21万+
一、什么是反射： 反射是Java的特征之一，是一种间接操作目标对象的机制，核心是JVM在运行的时候才动态加载类，并且对于任意一个类，都能够知道这个类的所有属性和方法，调用方法/访问属性，不需要提前在编译期知道运行的对象是谁，他允许运行中的Java程序获取类的信息，并且可以操作类或对象内部属性。程序中对象的类型一般都是在编译期就确定下来的，而当我们的程序在运行时，可能需要动态的加载一些...
Java基础知识总结（2021版）
热门推荐
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
Java基础篇：数组
张维鹏的博客
10-10 3万+
数组是一种线性数据结构，是一个使用连续的内存空间存放相同的数据类型的集合容器，与其他容器相比，数组的区别主要在于性能与保存基本类型的能力。 在Java中，数组是一种效率最高的存储和随机访问对象的方式，通过寻址公式，随机访问的时间复杂可以达到O(1)，但是为了保持空间的连续性，在数组中插入、删除数据时，都需要移动后面数据，该操作的时间复杂度为O(n)。另外，由于空间上连续，所以数组对CPU缓存比较友好，借助CPU的缓存机制，预读数组中的数据，提高访问效率。但是，由于数组是定长
Java面试基础篇
qq_24095055的博客
03-13 1万+
Java面试基础篇 基础总结 博客链接导航 Java的强引用、弱引用、软引用、虚引用 https://blog.csdn.net/qq_24095055/article/details/88528214
Java基础知识面试题
学Java，找哪吒
08-24 5万+
一、JDK 和 JRE 有什么区别？ JDK（Java Development Kit），Java开发工具包 JRE（Java Runtime Environment），Java运行环境 JDK中包含JRE，JDK中有一个名为jre的目录，里面包含两个文件夹bin和lib，bin就是JVM，lib就是JVM工作所需要的类库。 二、== 和 equals 的区别是什么？ 1、对于基本类型，==比较的是值； 2、对于引用类型，==比较的是地址； 3、equals不能用于基本类型的比较； 4、如果
java基础知识点
学Java，找哪吒
09-18 2万+
🏆作者简介：哪吒，CSDN2022博客之星Top1、CSDN2021博客之星Top2、多届新星计划导师✌、博客专家💪，专注Java硬核干货分享，立志做到Java赛道全网Top N。🏆本文收录于，，目前已经700+订阅，CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。🏆姐妹篇，，包含面向对象、基本数据类型、数组、继承和多态、泛型、枚举等Java基础知识点。🏆姐妹进阶篇，
Java学习路线总结（思维导图篇）
学Java，找哪吒
10-21 18万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
JAVA基础（面试篇）
对博客内容有任何疑问，欢迎私信我
10-25 3871
一、JAVA基础 1、什么是面向对象？ 封装、继承、多态 2、对异常有什么看法？一般会如何做处理？（finally会用来做什么，关闭流的时候会放在哪个地方？） 异常是程序在编译或者运行的时候出现问题的显相； Throwable是所有Error（非程序问题，首要解决目标以及性能调优）和Exception（程序问题，且可处理可调式）的父类； 手动处理异常，可提升程序的健壮性； 3、JAVA中堆和栈的区别，说下java的内存机制。（引用类型能打印出来么？当打印一个String申明的变量时，打印出来的是什么？.
java基础——入门篇
07-14
Java基础入门篇主要涵盖了一系列关于Java编程语言的基础知识，包括JVM（Java虚拟机）、Java开发环境的搭建、Java的历史、特点、程序类型、垃圾收集器、J2SE的下载和安装，以及环境变量的配置和测试。此外，还会介绍...
java程序设计基础篇
09-24
本书是java程序设计的基础篇。是英文版的。适合英语水平较好的java初学者观看。也适合开发人员的参考用书。中文版的可以进一步咨询QQ945745429
java基础篇学习笔记
07-20
Java是一种广泛使用的面向对象的编程...这些Java基础知识点构成了学习Java编程的基石，对于理解和编写高质量的Java代码至关重要。通过不断实践和深入学习，开发者能够更好地掌握这些概念，进而解决更复杂的编程问题。
java基础篇
04-22
Java基础篇涵盖了许多核心概念，这些概念构成了Java编程语言的基础，是任何Java开发者必备的知识。以下是对这些基础知识的详细说明： 1. **Java简介**：Java是由Sun Microsystems开发的面向对象的编程语言，后来被...
java基础集合篇.wps
12-30
整理了一下java基础的集合部分，有list，map，set等及其相关。
JAVA进阶补充
2301_80150315的博客
08-15 1014
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 899
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1136
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
【Spring框架】
最新发布
m0_71941456的博客
08-18 836
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值