JavaEE初阶----多线程初阶----Thread

已于 2022-04-13 11:54:05 修改
阅读量1.7k 收藏 9
点赞数 11
分类专栏： JavaEE 文章标签： java 数据结构 算法 JavaEE 多线程
于 2022-03-31 12:14:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baiyang2001/article/details/123648394
版权

本文章为 javaEE初阶 教学

下一篇文章为：面试八股文，多线程进阶！点击这里进行跳转

通过此文章可以学习到：

1、计算机是如何工作的

2、什么是操作系统

3、什么是进程

4、操作系统如何管理进程

5、什么是PCB

6、PCB中的一些属性

7、什么是线程

8、线程和进程的区别

9、java中的Thread类用法

文章目录：

1、了解什么是API

2、关于操作系统

3、进程（跑起来的程序）

4、操作系统如何管理进程

5、PCB中的一些属性

6、进程的调度与隔离性

7、线程

8、经典面试题（线程和进程的区别）

9、Java中的 Thread 类

10、线程的状态

11、线程安全

12、什么是可重入

13、标准库

14、针对于内存可见性的另外一种解释

15、缓存

16、volatile 和 synchronized区别（仅针对于java）

17、wait 和 notify

18、线程安全的单例模型

19、阻塞队列实现—生产者消费者模型

20、定时器的模拟实现

21、线程池的模拟实现

1、了解什么是API

在这里插入图片描述

2、关于操作系统

在这里插入图片描述

3、进程（跑起来的程序）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4、操作系统如何管理进程

操作系统管理进程大体分为两部分：

  • 1、先描述一个进程
  • 2、再组织若干个进程（使用一些数据结构，把很多描述进程的信息放到一起，方便进行增删改查）
    在这里插入图片描述

5、PCB的一些属性

①、pid（进程的身份标识）

在这里插入图片描述

②、内存指针（指明即将执行的代码和指令在内存的哪里，以及这个进程执行中依赖的数据的位置）

在这里插入图片描述

那问题来了为什么需要这样一个内存指针

在这里插入图片描述

③、文件描述符表（程序的运行和文件息息相关）

在这里插入图片描述

上述PCB属性：

在这里插入图片描述

所谓进程调度：

在这里插入图片描述

例如：

在这里插入图片描述

这就是所谓的进程调度

在理解下面一组属性我们先需要了解一组知识：并发和并行

在这里插入图片描述

下面正式介绍PCB的下一组属性

通过一个小故事我们来理解一下这四个属性

在这里插入图片描述

①、状态

在这里插入图片描述
在这里插入图片描述

②、优先级

在这里插入图片描述

在这里插入图片描述

③、记账信息

在这里插入图片描述
在这里插入图片描述

④、上下文

在这里插入图片描述
在这里插入图片描述

通过这个例子我们就可以清楚的理解这四个PCB的属性了

在这里插入图片描述

6、进程的调度与隔离性

在这里插入图片描述

这里的知识我们再举个例子：

在这里插入图片描述
在这里插入图片描述

7、线程

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

8、经典面试题：线程与进程的区别

  • 1、进程包括线程，一个进程可以有一个或多个线程
  • 2、进程和线程是为了处理并发编程这样的场景，但是进程创建和销毁的开销较大，效率较低，相比之下，进程更加轻量，创建和销毁的效率更高（轻量是因为少了申请释放的过程）
  • 3、操作系统创建进程，要给进程分配资源，进程是操作系统分配资源的基本单位，操作系统创建线程，是要在CPU上调度执行的，线程是操作系统调度执行的基本单位
  • 4、进程具有独立性，每个进程有独自的虚拟地址空间，一个进程挂了，一般不会影响到其他进程，同一个进程中的多个线程，由于是公用一个内存空间，一个线程挂了，甚至导致整个进程崩溃
    在这里插入图片描述

9、Java中的 Thread 类

Thread类是什么？

在这里插入图片描述

9.1、五种创建方法

①、创建子类，继承于Thread

class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("这是一个线程");
    }
}
public class Test {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

②、创建一个类实现Runable接口再创建实例传给Thread类

class MyRunable implements Runnable{
    @Override
    public void run() {
        System.out.println("这是一个线程");
    }
}
public class Test {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunable());
        t.start();
    }
}

在这里插入图片描述

③、使用匿名内部类，简化方法1

public class Test {
    public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                System.out.println("这是一个线程");
            }
        };
        t.start();
    }
}

在这里插入图片描述

④、使用匿名内部类，简化方法2

public class Test {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("这是一个线程");
            }
        });
        t.start();
    }
}

在这里插入图片描述

⑤、使用lambda表达式进一步简化

public class Test {
    public static void main(String[] args) {
       Thread t = new Thread(()-> System.out.println("这是一个线程"));
       t.start();
    }
}

在这里插入图片描述

9.2、多线程的作用

先看一个串行的代码：

在这里插入图片描述

虽然通过上述的代码可以发现执行效率显著提升，但也要注意一个问题;

在这里插入图片描述

9.3、其他属性和方法

①、为线程起别名

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

②、是否后台进程

在这里插入图片描述
在这里插入图片描述

上述代码的t1，t2都是前台进程：

在这里插入图片描述

③、是否存活

在这里插入图片描述
在这里插入图片描述

9.4、Thread中的一些方法

9.4.1、run方法

在这里插入图片描述

9.4.2、中断线程

①、手动设置标志位

在这里插入图片描述

②、使用线程中的方法设置标志位
public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
           while(!Thread.currentThread().isInterrupted()){
               System.out.println("hello thread");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        t.start();
        Thread.sleep(5000);
        t.interrupt();
    }
}

在这里插入图片描述

public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
           while(!Thread.currentThread().isInterrupted()){
               System.out.println("hello thread");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
                   break;
               }
           }
        });
        t.start();
        Thread.sleep(5000);
        t.interrupt();
    }
}

在这里插入图片描述

9.4.3、线程等待

两个版本：一个-----线程等待没有时间限制（死等）

在这里插入图片描述

另外一个版本：有时间限制

在这里插入图片描述

在这里插入图片描述

9.4.4、获取当前线程的名字

在这里插入图片描述

9.4.5、线程休眠

在这里插入图片描述

10、线程的状态

10.1、NEW

在这里插入图片描述

10.2、TERMINATED

在这里插入图片描述

10.3、RUNNABLE

在这里插入图片描述

10.4、TIME_WAITING

在这里插入图片描述

10.5、BLOCK

在这里插入图片描述

10.6、WAITING

在这里插入图片描述

总结：

在这里插入图片描述

11、线程安全

在这里插入图片描述

11.1、什么情况下认为线程是安全的

在这里插入图片描述

11.2、一个线程不安全的典型案例

在这里插入图片描述

11.3、如何解决线程安全问题

在这里插入图片描述

11.4、产生线程不安全的原因

在这里插入图片描述

11.5、synchronized的用法

在这里插入图片描述

总结上述知识：

在这里插入图片描述
在这里插入图片描述

12、可重入

在这里插入图片描述

12.1、什么是死锁

在这里插入图片描述

这样的问题就是死锁

所以在设计synchronized的时候：

在这里插入图片描述
在这里插入图片描述

12.2、死锁的其他使用从场景

在这里插入图片描述

12.3、死锁的四种必要条件

在这里插入图片描述

13、标准库

在这里插入图片描述

14、针对于内存可见性的另外一种解释

在这里插入图片描述

15、缓存

在这里插入图片描述

16、volatile和synchronized区别（仅针对于java)

在这里插入图片描述

17、wait 和 notify

在这里插入图片描述
在这里插入图片描述

18、单例模型

预备知识：

在这里插入图片描述

18.1、饿汉模型

在这里插入图片描述

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Lenovo
 * Date: 2022-03-31
 * Time: 9:29
 */
//线程安全的单例模型
    //1、饿汉模型
class Singleton{
    private static Singleton instance = new Singleton();

    private Singleton(){};

    public static Singleton getInstance() {
        return instance;
    }
}
public class Demo {
    public static void main(String[] args) {
        Singleton instane = Singleton.getInstance();
    }
}

18.2、懒汉模型

在这里插入图片描述

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Lenovo
 * Date: 2022-03-31
 * Time: 9:31
 */
//线程安全的单例模型 懒汉模型
class Singleton2{
    private volatile static Singleton2 instance = null;

    private Singleton2(){};

    public static Singleton2 getInstance() {
        if(instance == null){
            synchronized (Singleton2.class){
                if(instance == null){
                    instance = new Singleton2();
                }
            }
        }
        return instance;
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Singleton2 instance = Singleton2.getInstance();
    }
}

19、阻塞队列实现—生产者消费者模型

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Lenovo
 * Date: 2022-03-31
 * Time: 9:34
 */
//通过阻塞队列实现生产者消费者模型
class MyBlockingQueue{
    private int[] data = new int[1000];
    private int head = 0;
    private int tail = 0;
    private int size = 0;

    private Object locker = new Object();

    public void put(int val) throws InterruptedException {
        synchronized (locker){
            if(size == data.length){
                locker.wait();
            }

            data[tail] = val;
            tail++;
            if(tail >= data.length){
                tail = 0;
            }

            size++;
            locker.notify();
        }
    }

    public Integer take() throws InterruptedException {
        synchronized (locker){
            if(size == 0){
                locker.wait();
            }

            int ret = data[head];
            head++;

            if(head >= data.length){
                head = 0;
            }

            size--;
            locker.notify();
            return ret;
        }
    }
}
public class Demo3 {
    public static void main(String[] args) {
        MyBlockingQueue qu = new MyBlockingQueue();
        Thread produce = new Thread(()->{
            int num = 0;
            while(true){
                System.out.println("生产了："+num);
                try {
                    qu.put(num);
                    num++;
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        produce.start();

        Thread consumer = new Thread(()->{
           while(true){
               try {
                   int num = qu.take();
                   System.out.println("消费了："+num);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        consumer.start();
    }
}

20、模拟实现定时器

在这里插入图片描述

import java.util.Comparator;
import java.util.concurrent.PriorityBlockingQueue;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Lenovo
 * Date: 2022-03-31
 * Time: 10:09
 */
//先描述一个任务
class MyTask{
    //任务具体是什么
    private Runnable runnable;

    //任务完成的具体时间
    private long time;

    //给任务初始化
    public MyTask(Runnable runnable,long delay){
        this.runnable = runnable;
        this.time = System.currentTimeMillis() + delay;
    }
    //执行任务
    public void run(){
        runnable.run();
    }

    public long getTime() {
        return time;
    }
}

//组织这些任务
class MyTimer {

    //使用带有优先级的阻塞队列
    PriorityBlockingQueue<MyTask> qu = new PriorityBlockingQueue<>(10, new Comparator<MyTask>() {
        @Override
        public int compare(MyTask o1, MyTask o2) {
            return (int) (o1.getTime() - o2.getTime());
        }
    });

    //把任务放到阻塞队列中
    public void schedule(Runnable runnable, long delay) {
        MyTask myTask = new MyTask(runnable, delay);
        //这里成功放一个元素就通知一下
        qu.put(myTask);
        synchronized (locker) {
            locker.notify();
        }
    }

    private Object locker = new Object();
    //创建一个扫描贤臣去寻找先执行的任务
    public MyTimer(){
        Thread t = new Thread(() -> {
            while (true) {
                try {
                    MyTask myTask = qu.take();
                    long curTime = System.currentTimeMillis();
                    //这里会造成忙等
                    if (curTime < myTask.getTime()) {
                        qu.put(myTask);
                        //等待差值的时间
                        synchronized (locker) {
                            locker.wait(myTask.getTime() - curTime);
                        }
                    } else {
                        myTask.run();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
    }
}
public class Demo4 {
    public static void main(String[] args) {
        MyTimer myTime = new MyTimer();
        myTime.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello timer");
            }
        },3000);
        System.out.println("main");
    }
}

21、模拟实现线程池

在这里插入图片描述

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Lenovo
 * Date: 2022-03-31
 * Time: 10:18
 */

//模拟实现线程池
class MyThreadPool{
    //创建任务并使用阻塞队列组织任务
    private BlockingQueue<Runnable> qu = new LinkedBlockingQueue<>();

    //创建一个工作类线程
    static class Worker extends Thread{
        private BlockingQueue<Runnable> qu = null;

        public Worker(BlockingQueue<Runnable> qu){
            this.qu = qu;
        }

        public void run(){
            while(true){
                //从阻塞队列中取出来一个任务执行
                try {
                    Runnable runnable = qu.take();
                    runnable.run();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //把执行好的线程组织在顺序表中
    List<Thread> workers = new ArrayList<>();
    public MyThreadPool(int n){
        for (int i = 0; i < n; i++) {
            Worker worker = new Worker(qu);
            worker.start();
            workers.add(worker);
        }
    }

    //把任务提交到阻塞队列中
    public void submit(Runnable runnable) throws InterruptedException {
        qu.put(runnable);
    }

}
public class Demo5 {
    public static void main(String[] args) throws InterruptedException {
        MyThreadPool pool = new MyThreadPool(10);
        for (int i = 0; i < 100; i++) {
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello pool");
                }
            });
        }
    }
}
梦の澜
关注
专栏目录
【JavaEE初阶】之 多线程基础【上篇】
m0_62547912的博客
10-28 568
多线程基础讲解
线程与进程的区别及线程实现（JavaEE初阶）
最新发布
wjianwei666的专栏
06-08 363
进程具有独立性，导致系统十分的稳定。但是线程不一样，多个线程共用一份地址空间，一旦某个线程出 bug，很可能会导致整个进程受到牵连，异常结束，所以多个线程之间容易相互影响。这里不可以吧 flag 设置成局部变量，因为变量捕捉的缘故，设置成局部变量的话，如果说 flag 之后要改变就捕捉不到，除非把 flag 设置成 final 修饰的常量。System.out.println("t1 结束了!System.out.println("t2 结束了!System.out.println("线程结束!
java thread 线程_Java Thread类简述
weixin_33420201的博客
02-20 145
今天我们来看下java.lang.Thread这个类。在学习Thread类之前，先看下线程相关知识：线程的几种状态、上下文切换，然后介绍Thread类中的方法的具体使用。1、线程的状态线程从创建到最终的消亡，要经历若干个状态。一般来说，线程包括以下这几个状态：创建(new)、就绪(runnable)、运行(running)、阻塞(blocked)、time waiting、waiting、消亡(d...
[Java并发]の几种线程的创建
Twenty-Seven的博客
08-02 430
1.方法一：直接使用Thread //创建线程对象 Thread t = new Thread(){ public void run(){ //要执行的任务代码 } }; //线程t启动 t.start(); 例如: Thread t1 = new Thread(){ @Override public void run(){ System.out.println("hello"); } }; t1.start(); 2..
java Thread的状态分析
很酷的站长的博客
11-14 537
在J.U.C中，许多与线程相关的类别，都提供了限时版和时版的API。这种状态下的线程相对正常，但是如果线程长时间停留在这种状态下，就不正常了，这表明线程运行的时间很长(有性能问题)，或者线程不能一直执行(有线程饥饿问题)。也就是说，如果没有特定的事件，那么处于这种状态的线程一直在等待，无法获得执行的机会。当线程执行完成后，run方法正常返回，或抛出运行异常而结束时，线程将停留在此状态。线程的状态是比较重要的，因此threadump显示这些状态，通过分析这些状态，可以得到线程的运行状况，发现可能存在的问题。
Thread线程和Handler消息处理机制(Android小游戏详解)
indeedes的博客
07-12 1283
讲解部分 做一个打地鼠的小游戏来了解Thread线程和Handler消息处理机制的工作方式。。 类文件需要完成的功能 • 1.记录洞穴的位置。创建一个二维数组，用于保存每个洞穴的位置坐标。 • 2.控制地鼠随机出现 （Thread线程和Handler消息处理机制) • 3.记录打到地鼠的个数并 显示。(简单的toast输出) 1.在Andorid中子线程不允许操作主线程中的组件（简单理解不能改变界面） 2.必须在子线程中更新UI组件，应该怎么办？ （通过Handler消息处理机制） ...
创建线程的3个方法
slgcsdn的博客
10-08 663
本文谈一谈创建线程的3个方法，看下文 方法1：直接使用Thread //创建线程对象 Thread t = new Thread(){ public void run(){ //要执行的任务 } }； //启动线程 t.start(); 方法二：使用Runnable配合Thread,目的是把【线程】和【任务】分开 Runnable runnable = new Runnable(){ public void run(){ //要执行的任务 } }； //创建线程对象 Thread t = new Threa
笔记14-JAVAEE之多线程初阶
12-16
【JavaEE之多线程初阶】 在JavaEE开发中，多线程是提升系统性能和并发处理能力的重要手段。本文将深入探讨多线程的基本概念、应用以及关键特性。 1. **认识线程（Thread）** 1.1 概念 - **线程是什么**：线程被...
Java学习资料 包括Javaee初阶，web前端，javascript,线程 Spring全家桶等等这些代码
06-21
首先，JavaEE（Java Platform, Enterprise Edition）是Java在企业级应用开发中的框架，初阶部分通常会涉及Servlet、JSP、JDBC等基础概念。Servlet是Java服务器端程序，用于扩展服务器的功能，处理HTTP请求。JSP...
【JavaEE初阶】多线程 _ 基础篇 _ 阻塞队列（案例二）
哎呀是小张啊 的博客
08-23 906
这篇博客主要介绍的是多线程的第二个案例 —— 阻塞队列，主要包含了 阻塞魔性的理论知识，以及 Java标准库 里面自带的阻塞队列的实现 和 自己手动去模拟一个阻塞队列的实现~~~~~~~~~~~~~~
Java多线程基础学习，Thread解读、java线程的状态、同步和异步、两阶段终止模式
清风
01-07 1204
理论概述 单线程和多线程 为什么要使用多线程呢？多线程有什么好处呢？ 如果在程序中，需要读写一个文件，该文件很大，那我们执行到该io操作时，cpu就会等待该io操作执行完才会继续运行下面的代码，进程调度相信大家都知道，操作系统会并发的调度使用每一个进程，使得cpu能给被充分使用，线程也是一样的，为了不让cpu傻等io操作我们可以多开一个线程，把这耗时的io操作放在另一个线程之中执行，这样cpu就能继续往下执行，这就是多线程的最大意义——榨干cpu资源。这里是并发的概念。 ...
java 三种多线程的创建方法Thread,Handler,Runnable
weixin_34346099的博客
11-02 123
 第一种方法:使用Thread 类的继承 public class myThread extends Thread { public void run() { for (int i = 0; i &lt; 10000; i++) { System.out.println(i); } } } 调用: myThread mmyThread = new myThread(); ...
java 线程异常后怎么解决_一个线程池中的线程异常了，那么线程池会怎么处理这个线程?...
weixin_39952074的博客
02-13 1056
线程池常用问题了解JDK Executors线程池吗?知道JDK提供了哪些默认的实现吗？看过阿里巴巴java开发手册吗？知道为啥不允许使用默认的实现吗？你们没有用默认的吧?那来介绍一下你们自定义线程池的几个常用参数呗？你这个几个参数的值是怎么得来的呀？算出来的？怎么算出来的？线程池里面的任务是IO密集型的还是计算密集型的呢？好，现在我们有一个自定义线程池了，来说一下你这个线程池的工作流程呗？那你这...
thread-interrupt
weixin_44748599的博客
03-21 97
被打断的线程在使用sleep，join， wait方法时候都能他受到InterruptedException打断信号抛出异常 打断sleep的线程 Thread t = new Thread(() -> { while(true){ } }); t.start(); try { // 如果直接打断，可能还没有起来呢， 所以这里简单休眠一下 Thread.sleep(100); } catch (InterruptedExcep
Thread类的基本用法
qq_44888950的博客
03-26 836
1.创建线程 方法1继承Thread类 class MyThread extends Thread{ @Override public void run() { System.out.println("Thread1"); } } public class Demo1 { public static void main(String[] args) { MyThread t = new MyThread(); t.st
Thread、Handler和HandlerThread关系何在？
梦里梦到醒不来的梦
09-02 9698
前言前几天看到一道面试题：Thread、Handler和HandlerThread有什么区别？，这个题目有点意思，对于很多人来说，可能对Thread和Handler很熟悉，主要涉及到Android的消息机制(Handler、Message、Looper、MessageQueue)
day013 多线程【Thread、线程创建】
MustangYL的博客
02-24 148
1 多线程 1.1多线程介绍 1.1.1 进程的概念 进程：进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。 1.1.2 线程的概念 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。 每一个线程都有一个做自己的栈空间,栈空间是线程私有的. 堆是多个线程共享的. 1.3 线程的调度模式 1.2 main线程
Thread 类的基本用法（附详细代码），通俗易懂。
gaoyu0914的博客
04-16 7845
1、线程创建 1.1 继承Thread类 1.2 实现Runnable接口 1.3 匿名内部类 1.4 使用lambda来创建Runnable 2、线程中断 3、线程等待 4、线程休眠 5、获取线程实例
intra-mart JavaEE 开发指南 Ver.7.1
该文档覆盖了多个Java组件的使用，包括邮件发送、外部过程调用、XML数据处理等，并详细阐述了与intra-mart Web Platform/App Framework Ver.7.1的集成开发方法。" 在intra-mart的JavaEE开发模型中，开发者可以利用...
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

梦の澜

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值