多线程系列（七）------ synchronized关键字简单使用以及可重入性

同步锁详解
最新推荐文章于 2024-10-14 08:50:25 发布
原创 最新推荐文章于 2024-10-14 08:50:25 发布 · 342 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#synchronized #多线程 #同步方法 #同步代码块 #可重入

本文深入剖析Java中的synchronize关键字，包括其基本使用、实例锁与全局锁的区别、并发访问的判断方法，以及可重入性的原理。

一、简介

            本文主要介绍synchronize的简单使用以及一些判断锁是否可以并发的例子。最后又分析了一下synchronize的可重入特性。

            本文主要参考： 

                       skywang12345 博主的文章  Java多线程系列--“基础篇”04之 synchronized关键字

                       noodleprince 博主的文章  Java可重入锁如何避免死锁

                       以及自己的部分整理。

            尊重原创，转载声明。

 

二、同步原理

  • 在java中，每一个对象有且仅有一个同步锁。这也意味着，同步锁是依赖于对象而存在。
  • 当我们调用某对象的synchronized方法时，就获取了该对象的同步锁。例如，synchronized(obj)就获取了“obj这个对象”的同步锁。
  • 不同线程对同步锁的访问是互斥的。也就是说，某时间点，对象的同步锁只能被一个线程获取到！通过同步锁，我们就能在多线程中，实现对“对象/方法”的互斥访问。 例如，现在有两个线程A和线程B，它们都会访问“对象obj的同步锁”。假设，在某一时刻，线程A获取到“obj的同步锁”并在执行一些操作；而此时，线程B也企图获取“obj的同步锁” —— 线程B会获取失败，它必须等待，直到线程A释放了“该对象的同步锁”之后线程B才能获取到“obj的同步锁”从而才可以运行。

 

三、使用方式

3.1 写法

  • 同步普通方法
public synchronized void fun1() {
    System.out.println("同步普通方法");
}

  • 同步静态方法

public static synchronized void fun2() {
    System.out.println("同步静态方法");
}

  • 同步代码块

public void fun3() {
    synchronized (this) {
        System.out.println("同步代码块");
    }
}

3.2 注意

  • synchronized代码块中的this是指的同步锁。也可以将this替换成其他对象。
  • 如果synchronized修饰的是同步代码块或者非静态的同步方法，则this代表的同步锁是实例锁，即当前对象，如果修饰的是静态的同步方法或者当前对象是单例对象，则同步锁代表的就是类锁，即当前类。
  • synchronized代码块可以更精确的控制冲突限制访问区域，有时候表现更高效率, 使用时要合理控制同步范围。

 

 

四、实例锁和全局锁

 

4.1 实例锁(对象锁)

  • 锁在某一个实例对象上；
  • 如果该类是单例，那么该锁也具有全局锁的概念； 
  •  实例锁对应的就是synchronized关键字。

4.2 全局锁(类锁)

  • 该锁针对的是类，无论实例多少个对象，那么线程都共享该锁；
  • 全局锁对应的就是static synchronized（或者是锁在该类的class或者classloader对象上）；

4.3 例子

  • 有一个类，里面包含了四个同步方法，俩个普通类型，俩个静态类型。请基于该类来判断四种组合是否可以同时访问
/**
 * @author qjwyss
 * @date 2019/4/1
 * @description
 */

public class Something {

    public synchronized void isSyncA() {
        method();
    }

    public synchronized void isSyncB() {
        method();
    }

    public static synchronized void cSyncA() {
        method();
    }

    public static synchronized void cSyncB() {
        method();
    }

    private static void method() {
        try {
            for (int i = 0; i < 5; i++) {
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName() + "输出的值：" + i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
  • 组合一：俩个线程共用同一个锁，分别访问俩个非静态的同步方法
public class Demo0-1 {

    public static void main(String[] args) {

        Something x = new Something();
        Something y = new Something();

        Thread thread1 = new Thread(() -> {
            x.isSyncA();
        });

        Thread thread2 = new Thread(() -> {
            x.isSyncB();
        });

        thread1.start();
        thread2.start();
    }

}

输出结果：

Thread-0输出的值：0
Thread-0输出的值：1
Thread-0输出的值：2
Thread-0输出的值：3
Thread-0输出的值：4
Thread-1输出的值：0
Thread-1输出的值：1
Thread-1输出的值：2
Thread-1输出的值：3
Thread-1输出的值：4

 结果说明： 不能同时访问，因为isSyncA()和isSyncB()都是访问同一个对象(对象x)的同步锁！

 

  • 组合二：俩个线程使用不同的对象锁，分别访问同一个非静态的同步方法
public class Demo0-2 {

    public static void main(String[] args) {

        Something x = new Something();
        Something y = new Something();

        Thread thread1 = new Thread(() -> {
            x.isSyncA();
        });

        Thread thread2 = new Thread(() -> {
            y.isSyncA();
        });

        thread1.start();
        thread2.start();
    }

}

输出结果：

Thread-1输出的值：0
Thread-0输出的值：0
Thread-1输出的值：1
Thread-0输出的值：1
Thread-1输出的值：2
Thread-0输出的值：2
Thread-0输出的值：3
Thread-1输出的值：3
Thread-1输出的值：4
Thread-0输出的值：4

结果说明： 可以同时访问，因为是俩个不同的对象锁。

  • 组合三： 俩个线程分别访问俩个不同的静态同步方法，使用俩个不同对象
public class Demo4-3 {

    public static void main(String[] args) {

        Something x = new Something();
        Something y = new Something();

        Thread thread1 = new Thread(() -> {
            x.cSyncA();
        });

        Thread thread2 = new Thread(() -> {
            y.cSyncB();
        });

        thread1.start();
        thread2.start();
    }

}

输出结果：

Thread-0输出的值：0
Thread-0输出的值：1
Thread-0输出的值：2
Thread-0输出的值：3
Thread-0输出的值：4
Thread-1输出的值：0
Thread-1输出的值：1
Thread-1输出的值：2
Thread-1输出的值：3
Thread-1输出的值：4

结果说明： 不能同时访问。因为虽说使用的是俩个不同的对象，可是此处访问的是俩个同步的静态方法，此时的锁是全局锁/类锁，都是Something这个类。另外，也不推荐使用实例对象来调用静态方法，此处仅仅是为了模拟这种情况。

  • 组合四：俩个线程一个调用非静态的同步方法，一个调用静态的同步方法，前者使用对象做锁，后者使用类做锁
public class Demo4-4 {

    public static void main(String[] args) {

        Something x = new Something();

        Thread thread1 = new Thread(() -> {
            x.isSyncA();
        });

        Thread thread2 = new Thread(() -> {
            Something.cSyncB();
        });

        thread1.start();
        thread2.start();
    }

}

输出结果：

Thread-0输出的值：0
Thread-1输出的值：0
Thread-1输出的值：1
Thread-0输出的值：1
Thread-0输出的值：2
Thread-1输出的值：2
Thread-1输出的值：3
Thread-0输出的值：3
Thread-0输出的值：4
Thread-1输出的值：4

结果说明：可以同时访问。因为一个是对象锁，一个是全局锁  对象锁和全局锁不一样。

 

4.4 原则

4.4.1 原则

  • 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程对“该对象”的该“synchronized方法”或者“synchronized代码块”的访问将被阻塞。
  • 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程仍然可以访问“该对象”的非同步代码方法或非同步代码块。
  • 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程对“该对象”的其他的“synchronized方法”或者“synchronized代码块”的访问将被阻塞。

4.4.2 例子

  • 俩个共用一把锁(此处this就是同一个runnable对象)的线程访问同一个synchronized方法或代码块，先持有锁的线程先访问，等第一个线程释放锁之后第二个线程才可以访问该同步方法或代码块。
/**
 * @author qjwyss
 * @date 2019/3/30
 * @description
 */
public class Demo1-1 {

    public static void main(String[] args) {

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                synchronized (this) {
                    try {
                        for (int i = 0; i < 5; i++) {
                            Thread.sleep(100);
                            System.out.println(Thread.currentThread().getName() + "输出的值：" + i);
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };


        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);

        thread1.start();
        thread2.start();

    }

}

 输出结果如下，始终不会出现交叉输出的情况：

Thread-0输出的值：0
Thread-0输出的值：1
Thread-0输出的值：2
Thread-0输出的值：3
Thread-0输出的值：4
Thread-1输出的值：0
Thread-1输出的值：1
Thread-1输出的值：2
Thread-1输出的值：3
Thread-1输出的值：4

 如果你真的理解了的话，请看下面这种情况，看看输出结果是否和你预想的一样，如果一样，那就是真的理解了：

/**
 * @author qjwyss
 * @date 2019/3/30
 * @description
 */
class MyThread extends Thread {
    @Override
    public void run() {
        synchronized (this) {
            try {
                for (int i = 0; i < 5; i++) {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + "输出的值：" + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Demo1-2 {

    public static void main(String[] args) {

        Thread thread1 = new MyThread();
        Thread thread2 = new MyThread();

        thread1.start();
        thread2.start();
    }
}

输出结果如下：

Thread-1输出的值：0
Thread-0输出的值：0
Thread-1输出的值：1
Thread-0输出的值：1
Thread-0输出的值：2
Thread-1输出的值：2
Thread-0输出的值：3
Thread-1输出的值：3
Thread-1输出的值：4
Thread-0输出的值：4

此处为什么又会交叉输出呢？  因为： 他们并非公用同一把锁，线程thread1使用的锁是thread1对象，即this是thread1对象，线程thread2使用的锁是thread2对象，即this是thread2对象。现在清楚的话那就是真的理解了。

 

  • 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程仍然可以访问“该对象”的非同步代码方法或非同步代码块。
/**
 * @author qjwyss
 * @date 2019/4/1
 * @description
 */

class Count {

    public synchronized void syncMethod() {
        try {
            for (int i = 0; i < 5; i++) {
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName() + "输出的值：" + i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void nonSyncMethod() {
        try {
            for (int i = 0; i < 6; i++) {
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName() + "输出的值：" + i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

public class Demo2 {

    public static void main(String[] args) {

        Count count = new Count();

        Thread thread1 = new Thread(() -> {
            count.syncMethod();
        });

        Thread thread2 = new Thread(() -> {
            count.nonSyncMethod();
        });

        thread1.start();
        thread2.start();
    }

}

输出结果如下：

Thread-1输出的值：0
Thread-0输出的值：0
Thread-1输出的值：1
Thread-0输出的值：1
Thread-0输出的值：2
Thread-1输出的值：2
Thread-0输出的值：3
Thread-1输出的值：3
Thread-0输出的值：4
Thread-1输出的值：4
Thread-1输出的值：5

 结果如上。虽然俩个线程共用了同一把锁，但是线程1对同步方法持有锁之后并不影响线程2对该对象的非同步方法的访问。

 

  • 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程对“该对象”的其他的“synchronized方法”或者“synchronized代码块”的访问将被阻塞。
/**
 * @author qjwyss
 * @date 2019/4/1
 * @description
 */

class Count {

    public synchronized void syncMethodA() {
        try {
            for (int i = 0; i < 5; i++) {
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName() + "输出的值：" + i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void syncMethodB() {
        synchronized (this) {
            try {
                for (int i = 0; i < 6; i++) {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + "输出的值：" + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

public class Demo3 {

    public static void main(String[] args) {

        Count count = new Count();

        Thread thread1 = new Thread(() -> {
            count.syncMethodA();
        });

        Thread thread2 = new Thread(() -> {
            count.syncMethodB();
        });

        thread1.start();
        thread2.start();
    }

}

输出结果：

Thread-0输出的值：0
Thread-0输出的值：1
Thread-0输出的值：2
Thread-0输出的值：3
Thread-0输出的值：4
Thread-1输出的值：0
Thread-1输出的值：1
Thread-1输出的值：2
Thread-1输出的值：3
Thread-1输出的值：4
Thread-1输出的值：5

 如上，始终不会出现交叉的情况。

 

五、可重入性 

5.1 例子

public class Widget {
    public synchronized void doSomething(){
        // do something
    }
}
public class LoggingWidget extends Widget {
    public synchronized void doSomething() {
        super.doSomething();
    }
}

这是《java并发编程实例》一书中的例子，并且书中说：“如果synchronized 不是可重入锁，那么LoggingWidget 的super.dosomething();无法获得Widget对象的锁，因为会死锁。” 

5.2 原理

乍一看好像不是这么回事，就算synchronized 不是可重入锁，可是synchronized 关键字一个在父类Widget 的方法上，另一个在子类LoggingWidget 的方法上，怎么会有死锁产生呢。

这里其实牵涉到了Java的重写。我们看子类LoggingWidget 的doSomething方法，重写了父类Widget 的doSomething方法，但是子类对象如果要调用父类的doSomething方法，那么就需要用到super关键字了。因为实例方法的调用是Java虚拟机在运行时动态绑定的，子类LoggingWidget 的对象调用doSomething方法，一定是绑定到子类自身的doSomething方法，必须用super关键字告诉虚拟机，这里要调用的是父类的doSomething方法。

子类对象，其实是持有父类Widget 的doSomething方法的，只需要使用super关键字告诉虚拟机要运行的是父类的doSomething方法，虚拟机会去调用子类对象中的父类Widget 的doSomething方法的。所以，super关键字并没有新建一个父类的对象，比如说widget，然后再去调用widget.doSomething方法，实际上调用父类doSomething方法的还是我们的子类对象。

那么这样就很好理解了，如果一个线程有子类对象的引用loggingWidget，然后调用loggingWidget.doSomething方法的时候，会请求子类对象loggingWidget 的对象锁；又因为loggingWidget 的doSomething方法中调用的父类的doSomething方法，实际上还是要请求子类对象loggingWidget 的对象锁，那么如果synchronized 关键字不是个可重入锁的话，就会在子类对象持有的父类doSomething方法上产生死锁了。正因为synchronized 关键字的可重入锁，当前线程因为已经持有了子类对象loggingWidget 的对象锁，后面再遇到请求loggingWidget 的对象锁就可以畅通无阻地执行同步方法了。

更进一步，将上面的示例代码改写一下，那么就算synchronized 不是可重入锁，也不会产生死锁的问题了。代码如下：

public class Widget {
    public synchronized void doSomething(){
        // do something
    }
}
public class LoggingWidget extends Widget {
    public synchronized void doSomething() {
        Widget widget = new Widget();
        widget.doSomething();
    }
}

在子类的doSomething方法中，直接新建了一个父类的对象widget，然后用这个父类对象来调用父类的doSomething方法，实际上请求的是这个父类对象widget的对象锁，就不涉及到可重入锁的问题了。 

六、多线程系列链接

  1. 多线程系列（一）------ 线程的状态及转换
  2. 多线程系列（二）------ 线程的创建方式
  3. 多线程系列（三）------ 线程常用方法
  4. 多线程系列（四）------ 线程优先级和守护线程和终止线程的方式

  5. 多线程系列（五）------ 死锁案例以及检测方法

  6. 多线程系列（六）------ 生产者消费者案例

  7. 多线程系列（七）------ synchronized关键字简单使用以及可重入性 
  8. 多线程系列（八）------ synchronized关键字原理以及锁优化
  9. volatile相关
  10. ThreadLocal相关
  11. 锁LOCK相关系列
  12. 原子类相关系列
  13. 并发集合相关系列
  14. 线程池相关系列
多线程系列(三) -synchronized 关键字使用详解
程序员志哥的博客
02-20 1133
在之前的线程系列文章中，我们介绍了线程创建的几种方式以及常用的方法介绍。我们接着聊聊多线程线程安全的问题，以及解决办法。
【多线程】synchronized 关键字 - 监视器锁 monitor lock
ZXT的博客
02-24 871
Java中synchronized关键字详解，synchronized特性，互斥性，可重入，多线程使用synchronized（修饰代码块，修饰普通方法，修饰静态方法）Java便准库中的线程安全类
(JAVA)从可重入性入手分析synchronized关键字的运行过程
涂修竹的专栏
03-22 322
最近在准备JAVA面试的时候遇到了一个问题，是关于java中synchronized的使用，基本上每次必考。但每次再面试官的深挖下回答上总会出现纰漏。所以借着下面这个问题，来好好总结一下synchronized的相关内容。synchronized 是否是可重入的？在维基百科中，可重入性互斥(Reentrant mutex)是这么定义的:In computer science, the reentra
synchronized关键字再回顾-脏读-可重入-锁升级
tom有cat
05-06 305
锁原理，锁升级
synchronized可重入锁解释
QiaoZhi486的博客
06-16 303
什么是可重入锁？ 可重入锁是锁的一个基本要求，是为了解决自己锁自己的情况。            比如以下伪代码：                        &nbsp
synchronized 是可重入锁吗？为什么？
Zsigner的博客
04-17 891
什么是可重入锁？ 关于什么是可重入锁，我们先来看一段维基百科的定义。 若一个程序或子程序可以“在任意时刻被中断然后操作系统调度执行另外一段代码，这段代码又调用了该子程序不会出错”，则称其为可重入（reentrant或re-entrant）的。即当该子程序正在运行时，执行线程可以再次进入并执行它，仍然获得符合设计时预期的结果。与多线程并发执行的线程安全不同，可重入强调对单个线程执行时重新进入同...
synchronized 关键字用法
梁靓凉的博客
03-10 930
synchronized 关键字最主要的三种使用方式： 1.修饰实例⽅法: 作⽤于当前对象实例加锁，进⼊同步代码前要获得当前对象实例的锁。 synchronized void method() { //业务代码 } 2.修饰静态⽅法: 也就是给当前类加锁，会作⽤于类的所有对象实例 ，进⼊同步代码前要获得当 前 class 的锁。因为静态成员不属于任何⼀个实例对象，是类成员（ static 表明这是该类的⼀个 静态资源，不管 new 了多少个对象，只有⼀份）。所以，如果⼀个线程 A 调⽤⼀个实例对象的 ⾮
java synchronized加载加锁-线程可重入详解及实例代码
08-31
Java中的`synchronized`关键字是用于实现线程同步的关键机制，它的主要目的是确保多线程环境下的数据一致性，防止数据竞争。在本例中，我们关注的是`synchronized`的线程可重入特性。 线程可重入是指一个线程已经...
Java 多线程与并发(4-26)-关键字- synchronized详解.pdf
07-21
"Java 多线程与并发(4-26)-关键字- synchronized详解" Java 多线程与并发中的 synchronized 关键字是实现同步块的互斥访问和线程的阻塞及唤醒等工作的重要工具。下面将对 synchronized 关键字进行详细分析。 ...
Java synchronized之“可重入锁”
wei_zhi的博客
09-21 3950
概念 可重入锁：自己可以再次获取自己的内部的锁。比如有线程A获得了某对象的锁，此时这个时候锁还没有释放，当其再次想获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。可重入锁也支持在父子类继承的环境中。实例package com.test.sync;public class Main { public int i = 10; synchronized publi
Java开发基础之Synchronized的三种应用方式
m0_58371965的博客
09-22 462
synchronized的三种应用方式 synchronized关键字最主要有以下3种应用方式，下面分别介绍 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁 修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁 修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码块前要获得给定对象的锁 1.synchronized作用于实例方法 我们设置类变量static为共享资源， 然后多个线程去修改。修改的含义是：先读取，计算，再写入。那么这个过程就不是原子的，多个
synchronized可重入的原理
最新发布
Flying_Fish_roe的博客
10-14 1785
可重入性（Reentrancy）指的是同一个线程在已经持有某个锁的情况下，可以再次获取该锁而不会被阻塞。换句话说，当一个线程已经获取了某个对象的锁后，它可以再次获取该锁，而不会导致死锁。的可重入性是Java并发编程中的一个关键特性，它通过在JVM中实现的监视器锁和计数器机制，使得同一线程可以多次获取同一个锁，而不会被阻塞或导致死锁。这种机制在编写复杂的多线程应用程序时尤为重要，特别是在涉及嵌套方法调用或递归的场景中。
synchronized底层原理
曹建涛的博客
03-06 565
一探究竟：反编译 三种使用场景，示例代码； public class SynchronizePrincipe { public synchronized static void fun1(){} public synchronized void fun2(){} public void fun3() { synchronized (this){} } } 通过javap -c -v命令反编译后（部分代码）； public static synchroni
多线程复习总结之解析Synchronized与重入锁
weixin_45974176的博客
04-17 2631
10分钟搞懂synchronized和重入锁
多线程：synchronized 关键字用法（修饰类，方法，静态方法，代码块）
热门推荐
萨达哈鲁的博客
12-19 2万+
多线程：synchronized 关键字用法（修饰类，方法，静态方法，代码块）synchronized用法synchronized修饰的对象有几种： 修饰一个类：其作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象； 修饰一个方法：被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 修饰一个静态的方法：其作用的范围是整个方法，作用的
Java多线程：synchronized的可重入性
weixin_30613727的博客
04-09 473
从Java多线程：线程间通信之volatile与sychronized这篇文章中我们了解了synchronized的基本特性，知道了一旦有一个线程访问某个对象的synchronized修饰的方法或代码区域时，该线程则获取这个对象的锁，其他线程不能再调用该对象被synchronized影响的任何方法。那么，如果这个线程自己调用该对象的其他synchronized方法，Java是如何判定的？这就涉及到...
【线程】synchronized的可重入性
m0_45406092的博客
11-01 3069
文章目录前言1. 线程安全与可重入性1.1. 线程安全1.2. 可重入1.2.1. 定义1.2.1.1 产生背景，操作系统的重入函数概念1.2.2. 可重入的条件1.3. 可重入与线程安全的关系2. synchronized的可重入性2.1. synchronized是可重入锁2.2. synchronized可重入锁的实现3.总结 前言 从Java多线程：线程间通信之volatile与sychronized这篇文章中我们了解了synchronized的基本特性，知道了一旦有一个线程访问某个对象的synch
C++面向对象编程(3)——常用关键字介绍(TODO)
FanFF的博客
11-16 458
C++关键字
代码中TODO关键字和标签的使用案例以及其解释
m0_53614338的博客
08-09 339
代码中TODO关键字和标签的使用案例以及其解释
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值