多线程

已于 2024-03-17 19:15:23 修改
阅读量1k 收藏 17
点赞数 26
分类专栏： java基础 文章标签： java
于 2024-03-15 19:52:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51578257/article/details/136742936
版权

1. 程序、进程与线程

程序(program)：

        为完成特定任务，用某种语言编写的 一组指令的集合。即指一段静态的代码，静态对象。

进程(process)：

        程序的一次执行过程，或是正在内存中运行的应用程序。如: 运行中的QQ，运行中的网易音乐播放器。

  • 每个进程都有一个独立的内存空间，系统运行一个程序即是一个进程从创建、运行到消亡的过程。(生命周期)
  • 程序是静态的，进程是动态的
  • 进程作为操作系统调度和分配资源的最小单位 (亦是系统运行程序的基本单位)，系统在运行时会为每个进程分配不同的内存区域
  • 现代的操作系统，大都是支持多进程的，支持同时运行多个程序。

线程(thread)：

        进程可进一步细化为线程，是程序内部的一条执行路径。一个进程中至少有一个线程。

  • 一个进程同一时间若并行执行多个线程，就是支持多线程的。

  • 线程作为CPU调度和执行的最小单位
  • 一个进程中的多个线程共享相同的内存单元，它们从同一个堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来 安全的隐患
  • 下图中，红框的蓝色区域为线程独享，黄色区域为线程共享

不同的进程之间是不共享内存的

进程之间的数据交换和通信的成本很高

2. 线程调度

分时调度

        所有线程轮流使用 CPU 的使用权，并且平均分配每个线程占用CPU的时间

抢占式调度

        让优先级高的线程以较大的概率优先使用CPU。如果线程的优先级相同，那么会随机选择一个线程随机性)，Java使用的为抢占式调度。

3. 多线程程序优点

背景：以单核CPU为例，只使用单个线程先后完成多个任务(调用多个方法)，肯定比用多个线程来完成用的时间更短（进程切换需要时间），为何仍需多线程呢?

多线程程序的优点：

  • 提高应用程序的响应。对图形化界面更有意义，可增强用户体验
  • 提高计算机系统CPU的利用率
  • 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

        单核CPU，在一个时间单元内，只能执行一个线程的任务。要想提升系统的性能，要么提升CPU性能，要么多加几个CPU，即为多核的CPU。

4. 并行与并发

并行(parallel)：

        指两个或多个事件在同一时刻发生（同时发生） 。指在同一时刻，有多条指令在多个CPU上同时执行。

并发(concurrency)：

        指两个或多个事件在同一时间段内发生。即在一段时间内，有多条指令在单个CPU上快速轮换、交替执行，使得在宏观上具有多个进程同时执行的效果。

        在操作系统中，启动了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单核 CPU 系统中，每一时刻只能有一个程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。
        而在多核 CPU 系统中，则这些可以并发执行的程序便可以分配到多个CPU上，实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。

5. 创建和启动线程

        Java语言的JVM允许程序运行多个线程，使用 java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例。

Thread类的特性：

  • 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，因此把run()方法体称为线程执行体。
  • 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()
  • 要想实现多线程，必须在主线程中创建新的线程对象。

5.1 方式一：继承Thread类

Java通过继承Thread类来创建并启动多线程的步骤如下：

  1. 定义Thread类的子类
  2. 重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务
  3. 创建Thread子类的实例，即创建了线程对象
  4. 调用线程对象的start()方法来启动该线程，start()会调用线程的run()方法 
public class ThreadTest {

    public static void main(String[] args) {

        // 3. 创建Thread子类的实例
        PrintNumber p1 = new PrintNumber();

        // 4. 调用线程对象的start()方法来启动该线程
        p1.start();
        // 不能让已经start()的线程再次start()

        // main()所在线程
        for (int i = 1; i <= 1000; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i + "*");
            }
        }


        // 创建另一个线程
        PrintNumber p2 = new PrintNumber();
        p2.start();


    }

}

// 1. 定义Thread类的子类
class PrintNumber extends Thread {

    // 2. 重写run()方法
    @Override
    public void run() {
        
        for (int i = 1; i <= 1000; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

两个线程交互进行

5.2 方式二： 实现Runnable接口

  1. 创建一个实现Runnable接口的类
  2. 实现接口中的run()（两种方法的run方法不是同一个，实际上Thread类实现了Runnable接口的run方法）
  3. 创建当前实现类的对象
  4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的实例
  5. 调用start()
// 1. 创建一个实现Runnable接口的类
class EvenNumberPrinter implements Runnable {

    // 2. 实现接口中的run()
    @Override
    public void run() {
        for (int i = 1; i <= 1000; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class ThreadTest1 {

    public static void main(String[] args) {
        
        // 3. 创建当前实现类的对象
        EvenNumberPrinter p1 = new EvenNumberPrinter();

        // 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的实例
        Thread t1 = new Thread(p1);

        // 5. 调用start()
        t1.start();

        // main()所在线程
        for (int i = 1; i <= 1000; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i + "*");
            }
        }

        // 创建另一个线程
        Thread t2 = new Thread(p1);
        t2.start();
    }
}

5.3 方式三：Callable

public class ThreadTest4 {

    public static void main(String[] args) {
        
        // 3. 创建Callable接口实现类的对象
        NumThread numThread = new NumThread();

        // 4. 将此Callable接口实现类的对象作为传递到FutureTask构造其中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);

        // 5. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        Thread t1 = new Thread(futureTask);
        t1.start();

        
        try {
            // 6. 获取Callable中call的返回值
            // 调用此方法会自动阻塞主线程直到return
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        
    }

}

// 创建一个Callable的实现类
class NumThread implements Callable {

    // 2. 实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

与Runnable方式的对比的好处

  • call()可以有返回值，更灵活
  • call()可以使用throws的方式处理异常，更灵活
  • Callable使用了泛型参数，可以指明具体的call()的返回值类型，更灵活

缺点：如果在主线程中需要获取分线程call()的返回值，则此时的主线程是阻塞状态的。

5.4 方式四：线程池 

public class ThreadTest5 {
    public static void main(String[] args) {
        // 1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);  // 初始十个线程
        ThreadPoolExecutor service1 = (ThreadPoolExecutor)service;
        // 设置相关参数
        service1.setMaximumPoolSize(50);  // 设置线程池中线程数的上限

        // 2. 执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
        // Runnable
        service.execute(new Thread1());
        service.execute(new Thread2());
        // // Callable
        // service.submit(Callable callable);

        // 3. 关闭连接池
        service.shutdown();
    }

}


class Thread1 implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class Thread2 implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

6. 线程常用方法

6.1 线程中的构造器

public Thread()：分配一个新的线程对象。
public Thread(String name)：分配一个指定名字的新的线程对象。
public Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
public Thread(Runnable target, String name)：分配一个带有指定目标新的线程对象并指定名字

6.2 线程中的常用方法

start()：启动线程；调用线程的run()
run()：将线程要执行的操作，声明在run()中
currentThread()：获取当前执行代码对应的线程
getName()：获取线程名
setName()：设置线程名
sleep(long millis)：静态方法，调用时，可以使得当前线程睡眠指定的毫秒数
yield()：静态方法，一旦执行此方法，就释放CPU的执行权
join()：在线程a中通过线程b调用该方法(b.join())，意味着线程a进入阻塞状态，直到线程b结束执行，线        
        程a才结束阻塞状态，继续执行
isAlive()：判断当前线程是否存活

6.3 线程中的优先级

Thread类内部声明的三个常量
MAX_PRIORITY (10):最高优先级
MIN _PRIORITY (1):低优先级
MORM_PRIORITY (5):曹通忧先级，默认情况下main线程具有昔通优先级。


getPriority():获取线程的优先级
setPriority():设置线程的优先级。范围[1,10]

7. 线程的生命周期

JDK1.5之前：5种状态

        线程的生命周期有五种状态: 新建(ew) 、就绪(Runnable) 、运行(Running) 、阻塞(Blocked) 、死亡(Dead)。CPU需要在多条线程之间切换，于是线程状态会多次在运行、阻塞、就绪之间切换。

 JDK1.5之后：

8. 线程的安全问题和同步机制

以售票为例

public class ThreadTest2 {

    // 三个窗口同时售卖100张票
    public static void main(String[] args) {

        SaleTicket s = new SaleTicket();

        Thread t1 = new Thread(s);
        Thread t2 = new Thread(s);
        Thread t3 = new Thread(s);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
        
    }

}

class SaleTicket implements Runnable {

    int ticket = 100;

    @Override
    public void run() {
        
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "售票，票号为" + ticket);
                ticket--;
            } else {
                break;
            }
            
        }

    }
}

        结合输出会发现有重票和错票，原因是线程1操作ticket的过程中，尚未结束的情况下，其他线程也参与进来，对tcket进行操作。因此，必须保证一个线程a在操作ticket的过程中，其它线程必须等待，直到线程a操作ticket结束以后，其它线程才可以继续操作ticket。 

Java解决线程安全问题——使用线程的同步机制

8.1 同步代码块

synchronized(同步监视器) {

    // 需要被同步的代码

}

        需要被同步的代码，即为操作共享数据的代码。

        共享数据：即多个线程需要操作的数据。

        需要被同步的代码，在被synchronized包裹后，就使得一个线程在操作这些代码的过程中，其他线程必须等待。

        同步监视器，俗称锁。哪个线程获得了锁，哪个线程就能执行需要被同步的代码。

        同步监视器可以使用任何一个类的对象充当，但是多个线程必须共用同一个同步监视器。

class SaleTicket implements Runnable {

    int ticket = 100;
    Object obj = new Object();

    @Override
    public void run() {
        
        while (true) {

            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized(obj) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "售票，票号为" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
            
            
        }

    }
}

8.2 同步方法

        如果操作共享数据的代码完整的声明在了一个方法中，那么我们就可以将此方法声明为同步方法。

        非静态的同步方法，默认监视器为this；静态的同步方法，监视器为当前类本身。

class SaleTicket implements Runnable {

    int ticket = 100;
    boolean isFlag = true;

    @Override
    public void run() {
        
        while (isFlag) {
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            show();
        }

    }

    public synchronized void show() {  // 此时默认监视器为this
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "售票，票号为" + ticket);
            ticket--;
        } else {
            isFlag = false;
        }
    }
}

9. lock

class Window extends Thread {
    static int ticket = 100;

    // 1. 创建Lock实例，需要确保多个线程共用同一个Lock实例
    private static final ReentrantLock lock = new ReentrantLock();


    @Override
    public void run() {
        
        while (true) {
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            try {

                // 2. 执行lock方法，锁定对共享资源的调用
                lock.lock();

                if (ticket > 0) {

                    System.out.println(Thread.currentThread().getName() + "售票，票号为" + ticket);
                    ticket--;
                } else {
                    break;
                }
            } finally {

                // 3. unlock()调用，释放对共享数据的锁定
                lock.unlock();
            }
        }
    }
}


public class ThreadTest2 {

    public static void main(String[] args) {

        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();
        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");
        w2.start();
        w1.start();
        w3.start();
        
    }
}

synchronized同步的方式与Lock的对比 

  • synchronized不管是同步代码块还是同步方法，都需要在结束一对{ }之后，释放对同步监视器的调用
  • Lock是通过两个方法控制需要被同步的代码，更灵活一些
  • Lock作为接口，提供了多种实现类，适合更多更复杂的场景，效率更高

10. 线程的通信

等待唤醒机制
        这是多个线程间的一种协作机制。在一个线程满足某个条件时，就进入等待状态(wait() / wait(time)) ， 等待其他线程执行完他们的指定代码过后再将其唤醒(notify())；或可以指定wait的时间，等时间到了自动唤醒，在有多个线程进行等待时，如果需要，可以使用notifyAll() 来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。

  1. wait: 线程不再活动，不再参与调度，进入 wat set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态是 WAITING 或 TIMED_WAITING，它还要等着别的线程执行一个特别的动作，也即“ 通知(notify) ”或者等待时间到，在这个对象上等待的线程从 wait set 中释放出来，重新进入到调度队列(ready queue)中
  2. notify: 则选取所通知对象的 wait set 中的一个线程释放
  3. notifyAll: 则释放所通知对象的 wait set 上的全部线程
  • 此三个方法必须在同步代码块或同步方法中使用
  • 此三个方法的调用者，必须是同步监视器
  • 此三个方法声明在Object中
public class ThreadTest3 {

    // 两个线程交替打印
    public static void main(String[] args) {
        PrintNum p = new PrintNum();

        Thread t1 = new Thread(p, "线程一");
        Thread t2 = new Thread(p, "线程二");

        t1.start();
        t2.start();
    }
}


class PrintNum implements Runnable {
    
    private int number = 1;
    @Override
    public void run() {

        while (true) {

            synchronized(this) {
                // 唤醒被wait()的线程中优先级最高的那一个线程，被唤醒的线程从当初被wait的地方继续执行
                notify();
                if (number <= 100) {
                    System.out.println(Thread.currentThread().getName() + ": " + number++);
                    try {
                        // 线程一旦执行此方法，就进入等待状态，同时，会释放对同步监视器的调用
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

 

当归. z Z
关注
专栏目录
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Java多线程（超详细！）
热门推荐
一只小菜鸡
05-13 13万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Python多线程爬虫——数据分析项目实现详解
Why_does_it_work的博客
01-17 6万+
爬虫和池是爬虫领域中不可或缺的概念，池能够提高爬虫的稳定性和效率，同时帮助爬虫更好地适应目标的反爬虫策略。
C# 多线程详细讲解
fenglearning的博客
05-27 2万+
C#多线程 一、基本概念 1、进程 首先打开任务管理器，查看当前运行的进程： 从任务管理器里面可以看到当前所有正在运行的进程。那么究竟什么是进程呢？ 进程（Process）是Windows系统中的一个基本概念，它包含着一个运行程序所需要的资源。一个正在运行的应用程序在操作系统中被视为一个进程，进程可以包括一个或多个线程。 线程是操作系统分配处理器时间的基本单元，在进程中可以有多个线程同时执行代码。进程之间是相对独立的，一个进程无法访问另一个进程的数据（除非利用分布式计算方式）， 一个进程运
多线程一，什么是多线程，创建多线程的几种方式
世上哪有什么岁月静好,不过是有人替你负重前行
04-11 2万+
1 多线程相关概念 并发（Concurrent）：在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。 同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。 并行（Parallel）：当系统有一个以上CPU时，当一个CPU执行一个进程时，另一个CPU可以执行另一个进程，两个进程互不抢占CPU资源，可以同时进行，这种方式我们称之为
Delphi多线程总结
疯流人物
10-23 2753
多线程总体认识 当前程序是一个进程, 进程只是一个工作环境, 线程是工作者; 每个进程都会有一个启动线程(或叫主线程), 也就是说: 大量的编码都是写给这个主线程的; ExitThread(0); 退出主线程; 系统不允许一个没有线程的进程存在, 所以程序就退出了. ExitThread 函数的参数是一个退出码, 这个退出码是给之后的其他函数用的, 这里随便给个无符号整数即可. ...
单核 CPU 支持 Java 多线程吗？我们来一起看看吧
吴名氏的博客
06-09 9万+
单核 CPU 支持 Java 多线程吗？我们来一起看看吧
【八股文】多线程篇
weixin_45325628的博客
02-22 5745
这里写目录标题一级目录二级目录三级目录 一级目录 二级目录 三级目录
多线程使用场景
weixin_43412919的博客
09-15 9520
工作当中多线程的使用场景总结
Springboot异步多线程编程
程序员小杨哥的博客
01-11 5874
同步、异步、进程、线程，springboot异步多线程编程学习
java多线程编程实例
延陵缥缈的博客
05-25 8万+
        这篇文章主要介绍了java多线程编程实例，分享了几则多线程的实例代码，具有一定参考价值，加深多线程编程的理解还是很有帮助的，需要的朋友可以参考下。1.相关知识：Java多线程程序设计到的知识：（1）对同一个数量进行操作（2）对同一个对象进行操作（3）回调方法使用（4）线程同步，死锁问题（5）线程通信等等2．示例2.1三个售票窗口同时出售20张票程序分析：    (1)票数要使用同一...
Android多线程文件夹下载及断点续传
08-07
在Android开发中，进行大文件下载时，为了提高效率并充分利用设备资源，通常会采用多线程下载技术。此外，为了提升用户体验，断点续传功能也显得尤为重要，尤其是在网络不稳定或者用户中断下载后，可以从上次停止的...
Qt 多线程及简单实例 demo
03-07
Qt 多线程及简单实例 demo。 多线程的几大特点： 1.多线程的执行顺序无法保证，与操作系统的调度策略和线程优先级等因素有关。 2.多线程的切换可能发生在任何时刻、任何地点。 3.多线程对代码的敏感度高，因此对...
Qt界面多线程opencv调用摄像头
05-09
本代码是在qt平台下opencv利用多线程调用摄像头进行实时的视频显示在gui界面上，利用的时QThread的方法，是本人用了一年时间在维护的代码，需要的可以前来下载。当然我这也有qt上位机部分的代码，有需要的可以在评论...
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 550
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
No provider available from registry RegistryDirectory
最新发布
小道仙的后宫
10-20 209
最近在做配置文件升级，服务比较多，之前的Dubbo配置各个服务写的比较乱，有的用Nacos上的 data-id，有的又是在自己的服务引入配置遂准备统一了，全部都用Nacos上的配置，同时修改了Dubbo服务名发到线上的时候，线上崩了，部分服务出现如下错误注： IP和服务名做了隐藏处理。
java 异常包装
fdvvg的博客
10-17 330
通过异常包装，可以在Java中有效地处理和传递异常。这样做不仅能保持原始异常的信息，还能为上层调用者提供更多的上下文信息。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 419
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值