java多线程梳理

于 2024-05-13 23:14:27 发布
阅读量1.6k 收藏 37
点赞数 51
分类专栏： javase 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46497587/article/details/138782655
版权

进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。（进程是资源分配的最小单位）

　　线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。（线程是cpu调度的最小单位）

 在java中要想实现多线程，有三种手段，一种是继承Thread类，一种是实现Runable接口.还有一种是实现Callable接口，并与Future、线程池结合使用。推荐使用Runable

 继承Thread类

package org.xiao.review.multhread;

/**
 *
 * @Author 笑道长
 * @Create 2024/5/13 8:06
 * @Version 1.0
 */
public class First extends Thread{
    private String name;
    public First(String name){
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + "运行i:" + i);

            try {
                sleep((int)Math.random() * 10);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}



public class Test {
    public static void main(String[] args) {
        First f1 = new First("f1");
        First f2 = new First("f2");

        f1.run();
        f2.run();
    }
}

运行结果

//第一次
f1运行i:0
f2运行i:0
f2运行i:1
f1运行i:1
f2运行i:2
f1运行i:2
f2运行i:3
f1运行i:3
f2运行i:4
//第二次
f2运行i:0
f1运行i:0
f1运行i:1
f2运行i:1
f1运行i:2
f2运行i:2
f1运行i:3
f2运行i:3
f1运行i:4
f2运行i:4

说明：

程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用f1、f2两个对象的start方法，另外两个线程也启动了。Thread.sleep()方法调用目的是不让当前线程独自霸占该进程所获取的CPU资源，以留出一定时间给其他线程执行的机会。

start()方法的调用后并不是立即执行多线程代码，而是使得该线程变为就绪态（Runnable），什么时候运行是由操作系统决定的。但是start方法重复调用的话，会出现java.lang.IllegalThreadStateException异常。

比如

public class Test {
    public static void main(String[] args) {
        First f1 = new First("f1");
        First f2 = new First("f2");

        First f3 = f1;

        f1.start();
        f3.start();
    }
}

输出

Exception in thread "main" java.lang.IllegalThreadStateException
	at java.base/java.lang.Thread.start(Thread.java:794)
	at org.xiao.review.multhread.Test.main(Test.java:20)
f1运行i:0
f1运行i:1
f1运行i:2
f1运行i:3
f1运行i:4

测试题：下面程序输出结果是什么 

public class Exer {
    public static void main(String[] args) {
        A a = new A();
        a.start(); //① 启动线程 ② 调用Thread类的run()

        B b = new B(a);
        b.start();

    }
}

//创建线程类A
class A extends Thread {
    @Override
    public void run() {
        System.out.println("线程A的run()...");

    }
}

//创建线程类B
class B extends Thread {
    private A a;

    public B(A a){
        super(a);
    }

}

输出 ：

线程A的run()...
线程A的run()...

说明：

super(a)会执行的代码是：

public Thread(Runnable target) {
    this(null, target, "Thread-" + nextThreadNum(), 0);
}

同时Thread.run()的源码是：

@Override
public void run() {
    if (target != null) {
        target.run();
    }
}

a作为target形参传入，完成了Thread对象的创建。当b对象获取cpu资源执行run函数时，a.run()也就执行了。所以会有两行线程A的run()...。这是尚硅谷的瞎几把代码，看一下源码就行，狗都不这么写

实现java.lang.Runnable接口

public class Thread2 implements Runnable{
    private String name;
    public Thread2(String name){
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + "运行i:" + i);

            try {
                Thread.sleep((int)Math.random() * 10);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}


public class Test {

    public static void main(String[] args) {
        new Thread(new Thread2("thread1")).start();
        new Thread(new Thread2("thread2")).start();
    }

}

输出：

thread1运行i:0
thread2运行i:0
thread2运行i:1
thread1运行i:1
thread2运行i:2
thread1运行i:2
thread2运行i:3
thread1运行i:3
thread2运行i:4
thread1运行i:4

说明：

在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。
Thread2类通过实现Runnable接口，使得该类有了多线程类的特征。run（）方法是多线程程序的一个约定。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。
实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。

使用匿名内部类对象来实现线程的创建和启动  

new Thread("新的线程！"){
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(getName()+"：正在执行！"+i);
		}
	}
}.start();

new Thread(new Runnable(){
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName()+"：" + i);
		}
	}
}).start();

Thread和Runnable的区别

实现Runnable接口比继承Thread类所具有的优势：
1）：适合多个相同的程序代码的线程去处理同一个资源
2）：可以避免java中的单继承的限制
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
4）：线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类
5）：如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。


注意：main方法其实也是一个线程。在java中所有线程都是同时启动的，至于什么时候，哪个先执行，完全看cpu的调度
实际上每次java程序运行时至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个jvm，每一个jvm就是在操作系统中启动了一个进程。

线程状态转换

1、新建状态（new）:新创建一个线程对象
2、就绪状态（runnable）: 线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中。线程已经准备好被操作系统调度，准备获取cpu资源。

注意：

程序只能对新建状态的线程调用start()，并且只能调用一次，如果对非新建状态的线程，如已启动的线程或已死亡的线程调用start()都会报错IllegalThreadStateException异常。
3、运行状态（running）:执行线程程序
4、阻塞状态（blocked）:阻塞状态是是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。(wait会释放持有的锁)
（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。（注意,sleep是不会释放持有的锁）
5、死亡状态（dead）:线程执行完毕或者因为异常退出

Thread类中定义了进程的状态，在jdk11中定义为 NEW, RUNNABLE,BLOCKED,WATTING,TIMED_WAITING,TERMINATED(dead);

public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called {@code Object.wait()}
         * on an object is waiting for another thread to call
         * {@code Object.notify()} or {@code Object.notifyAll()} on
         * that object. A thread that has called {@code Thread.join()}
         * is waiting for a specified thread to terminate.
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
    }

线程调度

调度程序优先级:Java线程有优先级，优先级高的线程会获得较多的运行机会。
 
Java线程的优先级用整数表示，取值范围是1~10，Thread类有以下三个静态常量(jdk11)：

    /**
     * The minimum priority that a thread can have.
     */
    public static final int MIN_PRIORITY = 1;

   /**
     * The default priority that is assigned to a thread.
     */
    public static final int NORM_PRIORITY = 5;

    /**
     * The maximum priority that a thread can have.
     */
    public static final int MAX_PRIORITY = 10;

Thread类的setPriority()和getPriority()方法分别用来设置和获取线程的优先级。
 每个线程都有默认的优先级。主线程的默认优先级为Thread.NORM_PRIORITY。
线程的优先级有继承关系，比如A线程中创建了B线程，那么B将和A具有相同的优先级。
JVM提供了10个线程优先级，但与常见的操作系统都不能很好的映射。如果希望程序能移植到各个操作系统中，应该仅仅使用Thread类三个静态常量作为优先级（上面提到的），这样能保证同样的优先级采用了同样的调度方式。
2、线程睡眠：Thread.sleep(long millis)方法，使线程转到阻塞状态。millis参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。sleep()平台移植性好。
3、线程等待：Object类中的wait()方法，导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 唤醒方法。这个两个唤醒方法也是Object类中的方法，行为等价于调用 wait(0) 一样。
4、线程让步：Thread.yield() 方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。
5、线程加入：join()方法，等待其他线程终止。在当前线程中调用另一个线程的join()方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。
6、线程唤醒：Object类中的notify()方法，唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。 直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。类似的方法还有一个notifyAll()，唤醒在此对象监视器上等待的所有线程。
 注意：Thread中suspend()和resume()两个方法在JDK1.5中已经废除，不再介绍。因为有死锁倾向。

常用函数说明

1、sleep(long millis): 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）

2、join():指等待t线程终止。
join是Thread类的一个方法，启动线程后直接调用，即join()的作用是：“等待该线程终止”，该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。
为什么要用join()方法
在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

不使用join方法

public class Thread2 implements Runnable{
    private String name;
    public Thread2(String name){
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "begin");
        for (int i = 0; i < 5; i++) {
            System.out.println(name + "运行i:" + i);

            try {
                Thread.sleep((int)Math.random() * 10);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }

        System.out.println(Thread.currentThread().getName() + "end");
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + "begin");
        Thread thread1 = new Thread(new Thread2("thread1"));
        Thread thread2 = new Thread(new Thread2("thread2"));
        thread1.start();
        thread2.start();
        System.out.println(Thread.currentThread().getName() + "end");
    }

}

输出：

mainbegin
mainend
Thread-0begin
Thread-1begin
thread1运行i:0
thread2运行i:0
thread1运行i:1
thread2运行i:1
thread1运行i:2
thread2运行i:2
thread1运行i:3
thread2运行i:3
thread1运行i:4
thread2运行i:4
Thread-0end
Thread-1end

可以看出main线程先子线程完成

使用join方法，使用join方法注意Interrupted Exception 异常

public class Test {

    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + "begin");
        Thread thread1 = new Thread(new Thread2("thread1"));
        Thread thread2 = new Thread(new Thread2("thread2"));
        thread1.start();
        thread2.start();
        try {
            thread1.join();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }


        try {
            thread2.join();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Thread.currentThread().getName() + "end");
    }

}

输出：

mainbegin
Thread-0begin
Thread-1begin
thread1运行i:0
thread2运行i:0
thread1运行i:1
thread2运行i:1
thread1运行i:2
thread2运行i:2
thread1运行i:3
thread2运行i:3
thread1运行i:4
thread2运行i:4
Thread-0end
Thread-1end
mainend

3、yield():暂停当前正在执行的线程对象，并执行其他线程。
        Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。
          yield()应该做的是让当前运行线程回到就绪状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被操作系统调度程序再次选中。
 
结论：在大多数情况下，yield()将导致线程从运行状态转到可运行状态。

sleep()和yield()的区别
        sleep()和yield()的区别):sleep()使当前线程进入阻塞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；yield()使当前线程重新回到就绪状态，所以执行yield()的线程有可能在进入到就绪状态后马上又被执行。
        sleep 方法使当前运行中的线程睡眼一段时间，进入阻塞状态，这段时间的长短是由程序设定的，yield 方法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于就绪状态，如有，则把 CPU  的占有权交给此线程，否则，继续运行原来的线程。所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程
       另外，sleep 方法允许较低优先级的线程获得运行机会，但 yield()  方法执行时，当前线程仍处在运行状态，所以，不可能让较低优先级的线程获得 CPU 占有权。在一个运行系统中，如果较高优先级的线程没有调用 sleep 方法，又没有受到 I\O 阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。

4、interrupt():不要以为它是中断某个线程！它只是线线程发送一个中断信号，让线程在无限等待时（如死锁时）能抛出抛出，从而结束线程，但是如果你吃掉了这个异常，那么这个线程还是不会中断的！
5、wait()

Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作，从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){...}语句块内。从功能上来说wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。相应的notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。

一道面试题目要求如下：

    建立三个线程，A线程打印10次A，B线程打印10次B,C线程打印10次C，要求线程同时运行，交替打印10次ABC

public class SynchronizNotify implements Runnable {

    private String name;
    private Object prev;
    private Object self;

    public SynchronizNotify(String name, Object prev, Object self) {
        this.name = name;
        this.prev = prev;
        this.self = self;
    }

    @Override
    public void run() {
        int count = 10;
        while (count > 0) {
            synchronized (prev) {
                synchronized (self) {
                    System.out.print(name);
                    count--;

                    self.notify();
                }
                try {
                    if (count != 0) prev.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}


public class Test {

    public static void main(String[] args) throws InterruptedException {
        Object a = new Object();
        Object b = new Object();
        Object c = new Object();
        SynchronizNotify pa = new SynchronizNotify("A", c, a);
        SynchronizNotify pb = new SynchronizNotify("B", a, b);
        SynchronizNotify pc = new SynchronizNotify("C", b, c);


        new Thread(pa).start();
        Thread.sleep(100);  //确保按顺序A、B、C执行
        new Thread(pb).start();
        Thread.sleep(100);
        new Thread(pc).start();
        Thread.sleep(100);
    }

}

输出：

ABCABCABCABCABCABCABCABCABCABC

该问题为三线程间的同步唤醒操作，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA循环执行三个线程。为了控制线程执行的顺序，那么就必须要确定唤醒、等待的顺序，所以每一个线程必须同时持有两个对象锁，才能继续执行。一个对象锁是prev，就是前一个线程所持有的对象锁。还有一个就是自身对象锁。主要的思想就是，为了控制执行的顺序，必须要先持有prev锁，也就前一个线程要释放自身对象锁，再去申请自身对象锁，两者兼备时打印，之后首先调用self.notify()释放自身对象锁，唤醒下一个等待线程，再调用prev.wait()释放prev对象锁，终止当前线程，等待循环结束后再次被唤醒。运行上述代码，可以发现三个线程循环打印ABC，共10次。程序运行的主要过程就是A线程最先运行，持有C,A对象锁，后释放A,C锁，唤醒B。线程B等待A锁，再申请B锁，后打印B，再释放B，A锁，唤醒C，线程C等待B锁，再申请C锁，后打印C，再释放C,B锁，唤醒A。看起来似乎没什么问题，但如果你仔细想一下，就会发现有问题，就是初始条件，三个线程按照A,B,C的顺序来启动，按照前面的思考，A唤醒B，B唤醒C，C再唤醒A。但是这种假设依赖于JVM中线程调度、执行的顺序。

 wait和sleep区别
共同点：
1. 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。wait默认0毫秒
2. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ，从而使线程立刻抛出InterruptedException。
   如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep /join，则线程B会立刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。
   需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用 interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到 wait()/sleep()/join()后，就会立刻抛出InterruptedException 。
不同点：
1. Thread类的方法：sleep(),yield()等
   Object的方法：wait()和notify()等
2. 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。
   sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
3. wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用
所以sleep()和wait()方法的最大区别是：
　　　　sleep()睡眠时，保持对象锁，仍然占有该锁；
　　　　而wait()睡眠时，释放对象锁。
　　但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException（但不建议使用该方法）。
sleep（）方法
sleep()使当前线程进入停滞状态（阻塞当前线程），让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会;
　　 sleep()是Thread类的Static(静态)的方法；因此他不能改变对象的机锁，所以当在一个Synchronized块中调用Sleep()方法是，线程虽然休眠了，但是对象的机锁并木有被释放，其他线程无法访问这个对象（即使睡着也持有对象锁）。
　　在sleep()休眠时间期满后，该线程不一定会立即执行，这是因为其它线程可能正在运行而且没有被调度为放弃执行，除非此线程具有更高的优先级。
wait（）方法
wait()方法是Object类里的方法；当一个线程执行到wait()方法时，它就进入到一个和该对象相关的等待池中，同时失去（释放）了对象的机锁（暂时失去机锁，wait(long timeout)超时时间到后还需要返还对象锁）；其他线程可以访问；
　　wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程。
　　wiat()必须放在synchronized block中，否则会在program runtime时扔出”java.lang.IllegalMonitorStateException“异常。

关于线程状态转换jdk5.0之前和jdk5.0之后有所不同。后面再写

从线程安全问题再过渡到同步机制会好点。后面再写。

最后还有线程之间的通信

参考：Evankaka-CSDN博客

尚硅谷杜红康老师的java笔记 

笑道长C
关注
  • 51
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值