java中如何启动一个新的线程三种方法

最新推荐文章于 2024-07-14 21:35:28 发布
最新推荐文章于 2024-07-14 21:35:28 发布
阅读量2.1w 收藏 58
点赞数 10
分类专栏： java 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010871655/article/details/108773317
版权

java开启新线程的三种方法：

方法1：继承Thread类

1）：定义bai一个继承自Java.lang.Thread类的du类A.

2）：覆盖zhiA类Thread类中的run方法。

3）：我们编写需要在run方法中执行的操作：run方法中的代码，线程执行体。

4）：在main方法（线程）中，创建一个线程对象并启动线程。

(1)创建线程类对象:                

A类   a  =  new   A类();

(2)调用线程对象的start方法:    

a.start();//启动一个线程

注意：不要调用run方法。如果run方法被称为对象调用方法，则仍然只有一个线程，并且没有启动新线程。

创建启动线程实例：

//定义一个类A 继承java.lang.Thread
class A extends Thread{
    //A类 覆盖Thread类中的 run方法
    @Override
    public void run(){
        //在run方法填写要执行的操作
        for (int j = 0 ;j<10;j++){
            System.out.println("执行方法A的逻辑"+j);
        }
     }
}

public Class B{
    public static void main(String[] args){
        for (int i = 0;i<50 ;i++){
            System.out.println(i);
            if(i==10){
                // 在线程中重开一个线程执行其他操作
                A a = new A();
                a.start();
            }
            try {
                if (i==10){
                    Thread.sleep(1000);
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}
方法2：实现Runnable接口

1）：定义要在java.lang.Runnable接口中实现的类A.请注意，A类不是线程类。

2）：覆盖A类Runnable接口中的run方法。

3）：我们编写需要在run方法中执行的操作：在run方法中，线程执行。

4）：在main方法（线程）中，创建一个线程对象并启动线程。

(1)创建线程类对象:

Thread  t = new Thread(new  A());    

(2)调用线程对象的start方法:

t.start();

代码实例：

//定义一个类C 实现java.lang.Runnable 接口 C类不是线程类
class C implements Runnable{
    //C类 覆盖Runnable接口中的 run方法
    @Override
    public void run(){
        //在run方法填写要执行的操作
        for (int j = 0 ;j<10;j++){
            System.out.println("执行方法C的逻辑"+j);
        }
    }
}

public Class B{

    public static void main(String[] args){
        for (int i = 0;i<100 ;i++){
            System.out.println(i);
            if(i==10){
                // 在线程中重开一个线程执行其他操作
                C c = new C();
                Thread t = new Thread(c);
                t.start();
            }
            try {
                if (i==10){
                    System.out.println(Thread.currentThread().getName());
                    Thread.sleep(1000);
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

方法3：直接在函数体使用

    public static void main(String[] args){

        for (int i=0;i<20;i++){
            System.out.println(i);
            if(i==10){

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

                try {
                    if (i==10){
                        System.out.println(Thread.currentThread().getName());
                        Thread.sleep(1000);
                    }
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }

    }

弊端：

1、每次都要new thread,新建了一个对象，导致对象性能差。

2、线程缺乏统一管理，可能无限制新建线程，相互之间出现竞争，极可能占用过多系统资源导致死机或者oom。

3、缺乏更多功能，比如：定时定时执行，定期执行，线程中断。

相比new Thread而言，Java提供的四种线程池的好处在于：

　　　①可复用存在的线程，减少对象的创建、消亡，性能较高。

　　　②有效控制并发线程数，提高了系统资源的使用率，避免了过多争夺系统资源，导致的堵塞。

　　　③提供了定时执行、定期执行、单线程、并发数控制等功能。

Java通过Executors提供了四种线程池

  •       newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。线程池的规模不存在限制。
  •       newFixedThreadPool 创建一个固定长度线程池，可控制线程最大并发数，超出的线程会在队列中等待。
  •       newScheduledThreadPool 创建一个固定长度线程池，支持定时及周期性任务执行。
  •       newSingleThreadPool 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

 newCachedThreadPool:

创建一个可缓存的线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，如无回收，则新建线程

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
  for(int i=0; i<10;i++){
     final int index=i;
      try{
             Thread.sleep(index*1000);
          }catch(InterruptedException e){
                e.printStackTrace();
          }
           cachedThreadPool.execute(new Runnable(){
                  @override
                      public  void  run(){
                             System.out.println(index);
                    }
            });
   }

newFixedThreadPool:

创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待，定长线程池的大小最好根据系统资源进行设置。

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
    final int index = i;
    fixedThreadPool.execute(new Runnable() {

        @Override
        public void run() {
            try {
                System.out.println(index);
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    });
}

newScheduledThreadPool:

创建一个定长线程池，支持定时及周期性任务执行，ScheduledExecutorService比Timer更安全，功能更强大。

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {

    @Override
    public void run() {
        System.out.println("delay 3 seconds");
    }
}, 3, TimeUnit.SECONDS);
此表示为延迟3秒执行
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {

    @Override
    public void run() {
        System.out.println("delay 1 seconds, and excute every 3 seconds");
    }
}, 1, 3, TimeUnit.SECONDS);
此表示为延迟1秒后每3秒执行一次

newSingleThreadPool:

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
    final int index = i;
    singleThreadExecutor.execute(new Runnable() {

        @Override
        public void run() {
            try {
                System.out.println(index);
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    });
}

 

newCachedThreadPool 特点：

1.核心线程数为零    2.最大线程数为无限  3.无任务时，线程存活的最大时间为60s  4.任务队列为同步移交队列，该队列没有缓冲区，即不会有任务会在该队列中排队，每当有任务要入队时，队列都会将任务移交给一个可用的线程

为什么叫缓存线程池，类比于redis缓存：

前者缓存的是频繁要用到的线程；后者缓存的是频繁要用到的数据

前者通过缓存线程，避免了每次执行任务都要创建、销毁线程的开销；后者通过缓存数据，避免了每次用到数据都要操作db

两者都有缓存失效的时间，前者对应keepAliveTime参数，超过该参数对应的时间后，销毁线程；后者当缓存对应的真实数据被修改时，缓存失效，清除数据

为了尽量重复利用缓存的线程，而不是每次要执行任务时创建新的线程，应尽量使执行任务的时间小于keepAliveTime参数，默认是60s

因为是一个“缓存”线程池，没有缓存可以永久有效，因此核心线程数为0。因此任务队列的缓冲区应为空，否则即便系统有可用的线程资源，当有新的任务时也不会被执行，而是进入任务队列排队直至队列满，这显然是不合理的。同样由于队列缓冲区为空，每来一个任务时，都会在必要时新建线程执行任务，这就有可能导致大量的线程被创建，进而系统瘫痪。

 

１　newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。Executors.newCachedThreadPool(); 缺点：大家一般不用是因为newCachedThreadPool 可以无线的新建线程，容易造成堆外内存溢出，因为它的最大值是在初始化的时候设置为 Integer.MAX_VALUE，一般来说机器都没那么大内存给它不断使用。当然知道可能出问题的点，就可以去重写一个方法限制一下这个最大值
２　newFixedThreadPool  Executors.newFixedThreadPool(3);创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。可参考PreloadDataCache。其实newFixedThreadPool()在严格上说并不会复用线程，每运行一个Runnable都会通过ThreadFactory创建一个线程
３　newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。Executors.newScheduledThreadPool(5);与Timer 对比：Timer 的优点在于简单易用，但由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，同一时间只能有一个任务在执行，前一个任务的延迟或异常都将会影响到之后的任务（比如：一个任务出错，以后的任务都无法继续）。
ScheduledThreadPoolExecutor的设计思想是，每一个被调度的任务都会由线程池中一个线程去执行，因此任务是并发执行的，相互之间不会受到干扰。需要注意的是，只有当任务的执行时间到来时，ScheduedExecutor 才会真正启动一个线程，其余时间 ScheduledExecutor 都是在轮询任务的状态。
通过对比可以发现ScheduledExecutorService比Timer更安全，功能更强大，在以后的开发中尽可能使用ScheduledExecutorService(JDK1.5以后)替代Timer
４　newSingleThreadExecutor Executors.newSingleThreadExecutor()　创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。现行大多数GUI程序都是单线程的。Android中单线程可用于数据库操作，文件操作，应用批量安装，应用批量删除等不适合并发但可能IO阻塞性及影响UI线程响应的操作。

 

下面举一个newFixedThreadPool 应用示例：

 

import AThreadService;

//调用自己写好的异步处理逻辑的方法
public A {
    @Autowired
  	private AThreadService AThreadService;
    public static void main (String [] args){
        AThreadService.AThread((String)A,(Object)B, (String)C);
    }
}


// 接口
public interface AThreadService {
	/**
	 * 方法名称: AThread
	 * @throws
	 */
	public void  AThread(String A, Object B, String C);
	
}

//实现类
public class AThreadSpringImpl  implements AThreadService{

	@Autowired
	private AService AService;
	
    //线程根据实际情况设置大小
	private static final ExecutorService AThreadPool = Executors.newFixedThreadPool(10);

	public void AThread(String A, Object B,String C) {
		// TODO Auto-generated method stub
		AThread aThread = new AThread(A,B,C);
		AThread.setAService(AService);
		AThreadPool.execute(AThread);
	}
	
}

//线程类实现runable接口
public class AThread implements Runnable {
	
	private Log log = LogFactory.getLog(AThread.class);
	
	private static final long serialVersionUID = 1L;

	private String A;
	private Object B;
	private String C;
	private AService AService;
	
	public AService AService() {
		return aService;
	}

	public void setAService(AService aService) {
		this.aService = aService;
	}

    public  AThread(String A, Object B, String C)
    {
     this.A=A;
     this.B=B;
     this.C=C;
    }
    
    public void run() {
		// TODO Auto-generated method stub
    	log.info("-----------开始----------");
    	
		aService.afunction(A, B, C);
		
		log.info("-----------结束----------");
	}

}

// 实现类实现方法
public class AServiceSpringImpl implements AService {
	 
	/** 
	 *  
	 * 方法名称: afunction 
	 * @throws 
	 */ 
	public void afunction(String A,Object B,String C){ 
         
        //Do something;
        System.out.println("业务逻辑");
	} 
}

    在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程，这样一方面是线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了资源的开销。而线程池不允许使用Executors去创建，而要通过ThreadPoolExecutor方式，这一方面是由于jdk中Executor框架虽然提供了如newFixedThreadPool()、newSingleThreadExecutor()、newCachedThreadPool()等创建线程池的方法，但都有其局限性，不够灵活；另外由于前面几种方法内部也是通过ThreadPoolExecutor方式实现，使用ThreadPoolExecutor有助于大家明确线程池的运行规则，创建符合自己的业务场景需要的线程池，避免资源耗尽的风险。

    详细内容参考：https://www.cnblogs.com/dafanjoy/p/9729358.html

    线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。 说明：Executors返回的线程池对象的弊端如下：
1）FixedThreadPool和SingleThreadPool:
  允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
2）CachedThreadPool:
  允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。
            
Positive example 1：
    //org.apache.commons.lang3.concurrent.BasicThreadFactory
    ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1,
        new BasicThreadFactory.Builder().namingPattern("example-schedule-pool-%d").daemon(true).build());
       
        
            
Positive example 2：
    ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
        .setNameFormat("demo-pool-%d").build();

    //Common Thread Pool
    ExecutorService pool = new ThreadPoolExecutor(5, 200,
        0L, TimeUnit.MILLISECONDS,
        new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

    pool.execute(()-> System.out.println(Thread.currentThread().getName()));
    pool.shutdown();//gracefully shutdown
       
        
            
Positive example 3：
    <bean id="userThreadPool"
        class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <property name="corePoolSize" value="10" />
        <property name="maxPoolSize" value="100" />
        <property name="queueCapacity" value="2000" />

    <property name="threadFactory" value= threadFactory />
        <property name="rejectedExecutionHandler">
            <ref local="rejectedExecutionHandler" />
        </property>
    </bean>
    //in code
    userThreadPool.execute(thread);

浅唱寂寞
关注
  • 10
    点赞
  • 踩
  • 58
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
JAVA开启线程的三种方式
yyqhwr的博客
06-27 3142
目录 继承Thread类 实现Runnable接口 通过Callable和Future创建对象 继承Thread类 定义Thread类的子类，并重写run（）方法 创建该子类的实例，即创建了线程对象 调用线程对象的start()方法类启动该线程 package com.cn.thread; /** * 1.定义Thread类的子类，并重写run（）方法 */ public...
java启动线程三种方式
12-22
在Java编程语言中，创建和启动线程有多种方法，主要分为三种常见的方式。下面将详细探讨这三种启动线程的方法及其优缺点。 1. 继承Thread类 Java允许我们通过继承Thread类来创建一个新的线程。在子类中重写Thread类...
JavaWeb 服务启动时，在后台启动加载一个线程
QQbet的专栏
10-22 837
JavaWeb 服务启动时，在后台启动加载一个线程。 目前，我所掌握的一共有两种方法，第一种是监听（Listener），第二种是配置随项目启动而启动的Servlet。 下面对这两种方法做一简单的介绍，（Mark一下，防止以后急用又忘记了）： 监听（Listener） 首先，我们创建一个监听的类，继承ServletContextListener，如下： [java] vie
Java开启线程执行异步任务的四种方式
最新发布
记录一名在读研究生的学习笔记、感悟、开发产物
07-14 1094
本文探讨了Java中初始化线程的四种常见方法：通过继承`Thread`类，实现`Runnable`接口，利用`Callable`与`FutureTask`组合以获取返回值，以及使用线程池高效管理线程。线程池能显著降低资源消耗、提升响应速度，并优化线程管理，避免因频繁创建和销毁线程导致的系统不稳定。文章还介绍了不同类型的线程池，如固定大小、缓存和单线程池，以及它们的内部机制和参数设定，帮助开发者更好地理解和应用多线程编程。
Java-开启一个新的线程
06-04 104
java实现多线程有2种方法：1扩展java.lang.Thread类；2实现java.lang.Runnable接口 下面举个例子，实现Runnable，来实现多线程 public class DoSomething implements Runnable { //实现Runnable接口 public void run() { ...
Java线程开启的三种方式
weixin_65459034的博客
05-02 1089
开启线程的三种方式
java开启新线程的三种方法
aijian3049的博客
11-21 279
方式1：继承Thread类 步骤: 1):定义一个类A继承于Java.lang.Thread类. 2):在A类中覆盖Thread类中的run方法. 3):我们在run方法中编写需要执行的操作：run方法里的代码,线程执行体. 4):在main方法(线程)中,创建线程对象,并启动线程. (1)创建线程类对象: A类 a = new ...
JAVA实现线程的三种方法
09-05
下面将详细阐述这三种方法及其特点。 1. 继承Thread类： 当你需要自定义线程的行为时，可以通过继承Thread类来实现。在子类中重写run()方法，这个方法包含了线程要执行的任务。例如： ```java class MyThread ...
java两个线程同时写一个文件
08-25
Java中的多线程可以通过以下三种方式实现： 1. 继承`Thread`类：创建新的线程类，重写`run()`方法，然后创建该类的实例并调用`start()`方法启动线程。 2. 实现`Runnable`接口：创建实现`Runnable`接口的类，重写`...
Java 创建线程的两个方法详解及实例
08-31
要产生一个线程，需要从 Java.lang.Thread 类派生一个新的线程类，并重载它的 run() 方法。 在 Java 中，类仅支持单继承，也就是说，当定义一个新的类的时候，它只能扩展一个外部类。这样，如果创建自定义线程类的...
java启动线程的3种方式对比分析
08-31
在主函数中，通过创建Thread对象并调用它的start()方法来启动新线程。这种方式的优点是线程类可以直接拥有自己的方法和属性，方便进行状态管理。但是，由于Java不支持多重继承，如果你的类已经继承了其他类，那么你...
Java创建线程的三种方法比较及用法.doc
09-30
在Java编程语言中，创建线程主要有三种方法：通过实现`Runnable`接口、通过实现`Callable`接口以及直接继承`Thread`类。这三种方法各有特点，适用于不同的场景。 1. **实现`Runnable`接口创建线程：** 这是最常见...
详解Java实现多线程的三种方式
09-02
当调用`start()`方法时，新线程开始执行`run()`中的代码。这种方式简单直观，但每个线程都有自己的`Thread`实例，如果需要共享数据，需要使用同步机制。 2. 实现Runnable接口 另一种创建线程的方式是实现Runnable...
详细解读JAVA多线程实现的三种方式
09-01
本文将详细解析Java中实现多线程的三种主要方式：继承Thread类、实现Runnable接口以及使用ExecutorService、Callable和Future。 1. 继承Thread类实现多线程 在Java中，创建一个新的线程最直接的方式就是继承Thread...
Java多线程中所有方法的解析
08-11
这是线程并行执行的关键，直接调用`run()`方法不会启动新线程，而是在当前线程中执行。 2. **synchronized 关键字** - `synchronized` 用于确保对共享数据的访问是线程安全的。它有两种用法：修饰方法和同步代码块...
java中线程的创建常见有如三种基本形式实例
01-07
本文将详细讲解Java中线程的三种基本创建形式，并通过实例进行深入解析。 ### 1. 继承Thread类 Java提供了一个内置的`Thread`类，你可以通过继承它来创建一个新的线程。当你的类继承`Thread`后，你需要重写`run()`...
java启动线程的几种方式,java启动线程的三种方式
weixin_33739387的博客
03-12 141
package org.study.thread;/*** 启动一个线程的3种方式*/public class TraditionalThread {public static void main(String[] args) {// 1. 继承自Thread类(这里使用的是匿名类)new Thread(){@Overridepublic void run() {while(true) {try ...
java中开启一个新线程
qq_37996327的博客
09-12 4766
//实现方法pubRmRecordByRmPlanId @Override public OperateResult pubRmRecordByRmPlanId(Long rmPlanId,String taskBeginDate,UserInfo userInfo) { ... final String planId = String.valueOf(rmPlanId); ...
Java在项目中启动一个新线程
broccoli2的博客
07-14 2085
java 线程
使用Java实现线程有几种方法
08-12
### 回答1： 使用 Java 实现线程有两种方法： 1. 实现 Runnable 接口：通过实现 Runnable 接口并重写其 run() 方法来创建线程。 2. 继承 Thread 类：通过继承 Thread 类并重写其 run() 方法来创建线程。 两种方法都是可行的，但是通常推荐使用实现 Runnable 接口的方法，因为继承了 Thread 类会导致继承树不再继续向上延伸，进而影响代码的复用性。 ### 回答2： 在Java中，实现线程有三种主要方法： 1. 继承Thread类：这是最基本的方法，需要创建一个继承自Thread类的子类，并重写其中的run()方法。run()方法中定义了线程执行的具体逻辑。然后可以通过创建子类对象，并调用其start()方法来启动线程。 2. 实现Runnable接口：这是另一种常见的方法，需要创建一个实现了Runnable接口的类，并实现其中的run()方法。然后可以将该实现类的对象作为参数传递给Thread类的构造方法，在构造Thread对象时将其包装成一个线程对象。然后调用线程对象的start()方法来启动线程。 3. 实现Callable接口：这是Java5版本之后引入的新特性。Callable接口与Runnable接口相似，都是定义了一个run()方法来执行线程的逻辑。但是不同的是，run()方法的返回值为void，而Callable的call()方法可以有返回值。使用Callable需要创建一个实现了Callable接口的类，并实现其中的call()方法。然后可以通过将该实现类的对象作为参数传递给ExecutorService类的submit()方法来启动线程，并获取call()方法的返回值。 以上是最常见的三种方法来实现线程。不同的方法适用于不同的场景，通过选择合适的方法可以更灵活地管理和控制线程的执行。 ### 回答3： 在Java中，有三种主要的方法可以实现线程： 1. 继承Thread类：创建一个新的类，继承Thread类，并重写run()方法。在run()方法中定义线程的逻辑和动作。然后可以创建该类的实例，并调用start()方法来启动新的线程。 2. 实现Runnable接口：创建一个新的类，实现Runnable接口，并重写run()方法。在run()方法中定义线程的逻辑和动作。然后可以创建Thread对象，将实现了Runnable接口的类的实例作为参数传递给Thread的构造方法，最后调用start()方法来启动新的线程。 3. 使用Executor框架：Executor框架是Java提供的线程池管理工具。它利用ExecutorService接口来管理线程池。可以使用Executors类中的一些静态方法来创建不同类型的线程池。然后使用submit()方法提交一个实现了Runnable接口或Callable接口的对象给线程池，线程池会自动分配线程来执行任务。 无论使用哪种方法，实现线程的本质都是通过创建Runnable对象，然后通过线程启动器(Thread类的start()方法或Executor框架)来调度执行。不过，继承Thread类更加直观，但不方便资源共享；而实现Runnable接口可以避免单继承局限，并且可以共享资源；使用Executor框架可以进一步简化线程管理和资源分配。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值