多线程基础知识

最新推荐文章于 2024-09-27 00:45:01 发布
最新推荐文章于 2024-09-27 00:45:01 发布
阅读量71 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leiboprime/article/details/130756085
版权

多线程

一 程序、进程与线程

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

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

  • 每个进程都有一个独立的内存空间，系统运行一个程序即是一个进程从创建、运行到消亡的过程。（生命周期）
  • 程序是静态的，进程是动态的
  • 进程作为操作系统调度和分配资源的最小单位（亦是系统运行程序的基本单位），系统在运行时会为每个进程分配不同的内存区域。
  • 现代的操作系统，大都是支持多进程的，支持同时运行多个程序。比如：现在我们上课一边使用编辑器，一边使用录屏软件，同时还开着画图板，dos窗口等软件。

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

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

4 多线程程序的优点：

  1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

  2. 提高计算机系统CPU的利用率

  3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

5 并行与并发

并行（parallel）：指两个或多个事件在同一时刻发生（同时发生）。指在同一时刻，有多条指令在多个CPU上同时执行。比如：多个人同时做不同的事

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

二 创建和启动线程

方式1：继承Thread类

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

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

举例：

package Test1;

public class EvenTest {
    public static void main(String[] args) {
        PrintNumber printNumber = new PrintNumber();//创建Thread子类的实例
        printNumber.start();//调用线程对象的start()方法来启动该线程

        for(int i = 1;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}


package Test1;

public class PrintNumber extends Thread{//定义Thread类的子类

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

方式2：实现Runnable接口

步骤如下：

  1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

  2. 创建Runnable实现类的实例，并以此实例作为Thread的target参数来创建Thread对象，该Thread对象才是真正
    的线程对象。

  3. 调用线程对象的start()方法，启动线程。调用Runnable接口实现类的run方法。

举例：

package Test1;

public class EvenTest1 {
    public static void main(String[] args) {

        //创建Runnable实现类的实例
        PrintNumber1 p = new PrintNumber1();

        //以此实例作为Thread的target参数来创建Thread对象
        Thread t1 = new Thread(p);

        //调用线程对象的start()方法，启动线程。
        t1.start();
        
        //main()执行的主线程操作
        for(int i = 1;i < 100;i++){
            if(i % 2 !=0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}


package Test1;

public class PrintNumber1 implements Runnable{//定义Runnable接口的实现类

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

对比两种方式

联系

Thread类实际上也是实现了Runnable接口的类。即：

public class Thread extends Object implements Runnable

区别

  • 继承Thread：线程代码存放Thread子类run方法中。

  • 实现Runnable：线程代码存在接口的子类的run方法。

实现Runnable接口比继承Thread类所具有的优势

  • 避免了单继承的局限性
  • 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。
  • 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。

三 Thread类的常用结构

1 构造器

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

2 线程中的常用方法

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

3 线程的优先级

getPriority():获取线程的优先级

setPriority():设置线程的优先级，范围[1,10]

Thread类内部声明的三个优先级常量：

  • MAX_PRIORITY（10）：最高优先级
  • MIN _PRIORITY （1）：最低优先级
  • NORM_PRIORITY （5）：普通优先级，默认情况下main线程具有普通优先级。

4 多线程的生命周期

1 JDK1.5之前：5种状态

在这里插入图片描述

2 JDK1.5及之后：6种状态

在这里插入图片描述

四 线程安全问题及解决

同步机制解决线程安全问题的原理

方式1 同步代码块

同步代码块：synchronized 关键字可以用于某个区块前面，表示只对这个区块的资源实行互斥访问。

格式:

synchronized(同步监视器){
     需要同步操作的代码
}

说明：

  • 需要被同步的代码：即为操作共享数据的代码
  • 共享数据：即多个线程都需要操作的数据，比如：ticket
  • 需要被同步的代码，在被synchronized包裹以后就使得一个线程在操作这些代码的过程中，其他线程必须等待
  • 同步监视器，俗称锁，哪个线程获得了锁哪个线程就能执行需要被同步的代码
  • 同步监视器，可以使用任何一个类的对象充当，但是，多个线程必须共用同一个同步监视器。

注意：

  • 在实现Runnable接口的方式中，同步监视器可以考虑用 this

  • 在继承Thread类的方式中，同步监视器可以考虑使用

    当前类.class

举例：

package Test1;

public class TicketTest {
    public static void main(String[] args) {
        SaleTicket s1 = new SaleTicket();
        Thread t1 = new Thread(s1);
        Thread t2 = new Thread(s1);
        Thread t3 = new Thread(s1);

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

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

}


package Test1;

public class SaleTicket implements Runnable{
    int ticket = 100;
    @Override
    public void run() {

        while(true){
            synchronized(this){
                if(ticket > 0){

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

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

        }
    }
}

方式2 同步方法

**同步方法：**synchronized 关键字直接修饰方法，表示同一时刻只有一个线程能进入这个方法，其他线程在外面等着。

格式：

public synchronized void method(){
    可能会产生线程安全问题的代码
}

说明：

  • 如果操作共享数据的代码完整的声明在一个方法中，那么我们就可以将此方法声明为同步方法
  • 非静态的同步方法，默认同步监视器为 this
  • 静态的同步方法，默认同步监视器为当前类本身

举例：

package Test1;

public class TicketTest1 {
    public static void main(String[] args) {
        SaleTicket1 s1 = new SaleTicket1();

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

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

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

}



package Test1;

public class SaleTicket1 implements Runnable{
    static int ticket = 100;
    static boolean isFlag = true;
    @Override
    public void run() {

        while(isFlag){
            show();
        }
    }
    public synchronized void show(){
        if(ticket > 0){

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

            System.out.println(Thread.currentThread().getName() + "售票，票号为：" + ticket);
            ticket--;
        }else{
            isFlag = false;
        }
    }
}

synchronized好处：解决了线程的安全问题

弊端：在操作共享数据时，多线程其实是串行执行的，意味着性能低。

懒汉式线程安全问题

package Test2;

public class LazyOne {
    private static LazyOne instance;

    private LazyOne(){}

    //方式1：
    public static synchronized LazyOne getInstance1(){
        if(instance == null){
            instance = new LazyOne();
        }
        return instance;
    }
    //方式2：
    public static LazyOne getInstance2(){
        synchronized(LazyOne.class) {
            if (instance == null) {
                instance = new LazyOne();
            }
            return instance;
        }
    }
    //方式3：
    public static LazyOne getInstance3(){
        if(instance == null){
            synchronized (LazyOne.class) {
                try {
                    Thread.sleep(1000);//加这个代码，暴露问题
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(instance == null){
                    instance = new LazyOne();
                }
            }
        }

        return instance;
    }

五 死锁

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。

一旦出现死锁，整个程序既不会发生异常，也不会给出任何提示，只是所有线程处于阻塞状态，无法继续。

举例：

package Test3;

public class DeadLockTest {
    public static  void main(String[] args) {
        StringBuilder s1 = new StringBuilder();
        StringBuilder s2 = new StringBuilder();
        new Thread(){
            @Override
            public void run(){
                synchronized(s1) {
                    s1.append("a");
                    s2.append("1");

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

                    synchronized (s2) {
                        s2.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run(){
                synchronized(s2){
                    s2.append("c");
                    s1.append("3");

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

                    synchronized(s1){
                        s1.append("d");
                        s2.append("4");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();
    }
}

诱发死锁的原因：

  • 互斥条件
  • 占用且等待
  • 不可抢夺（或不可抢占）
  • 循环等待

以上4个条件，同时出现就会触发死锁

解决死锁：

死锁一旦出现，基本很难人为干预，只能尽量规避。可以考虑打破上面的诱发条件。

针对条件1：互斥条件基本上无法被破坏。因为线程需要通过互斥解决安全问题。

针对条件2：可以考虑一次性申请所有所需的资源，这样就不存在等待的问题。

针对条件3：占用部分资源的线程在进一步申请其他资源时，如果申请不到，就主动释放掉已经占用的资源。

针对条件4：可以将资源改为线性顺序。申请资源时，先申请序号较小的，这样避免循环等待问题。

六 JDK5.0新特性：Lock(锁)

JDK5.0的新增功能，保证线程的安全。与采用synchronized相比，Lock可提供多种锁方案，更灵活、更强大。Lock通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

  • 在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

    • ReentrantLock类实现了 Lock 接口，它拥有与 synchronized 相同的并发性和内存语义，但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。

  • Lock锁也称同步锁，加锁与释放锁方法，如下：

    • public void lock() :加同步锁。
    • public void unlock() :释放同步锁。

代码结构：

class A{
    //1. 创建Lock的实例，必须确保多个线程共享同一个Lock实例
	private final ReentrantLock lock = new ReenTrantLock();
	public void m(){
        //2. 调动lock()，实现需共享的代码的锁定
		lock.lock();
		try{
			//保证线程安全的代码;
		}
		finally{
            //3. 调用unlock()，释放共享代码的锁定
			lock.unlock();  
		}
	}
}

举例：

package Test3;

import java.util.concurrent.locks.ReentrantLock;

class Window implements Runnable{
    int ticket = 100;
    private  final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run(){
        while(true){
            try{
                lock.lock();
                if(ticket > 100){

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

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

public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t1.start();
        t2.start();
    }
}

synchronized与Lock的对比

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

七 线程的通信

1 为什么要处理线程间通信：

当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么多线程之间需要一些通信机制，可以协调它们的工作，以此实现多线程共同操作一份数据。

比如：线程A用来生产包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，此时B线程必须等到A线程完成后才能执行，那么线程A与线程B之间就需要线程通信，即—— 等待唤醒机制。

2 等待唤醒机制

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

3 涉及到三个方法的使用：

  • wait():一旦执行此方法，就进入等待状态，同时会释放同步监视器的调用
  • notify():一旦执行此方法，就会唤醒被wait()的线程中优先级最高的那一个线程。（如果被wait()的多个线程的优先级相同，随机唤醒一个）。被唤醒的线程从当初被wait的位置继续执行。
  • notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。

注意：

  • 此三个方法的使用，必须是在同步代码块或同步方法中
  • 此三个方法的调用者，必须是同步监视器。否则，会报illegamonitorStateException异常
  • 此三个方法声明在Object类中

4 举例：使用两个线程打印 1-100。线程1, 线程2 交替打印

package Test3;

public class PrintNumber implements Runnable{
    int number = 1;
    @Override
    public void run(){
        while(true){
            synchronized (this) {
                notify();//唤醒
                if(number <= 100){

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

                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;

                    try{
                        wait();//程序一旦执行此方法，就进入等待，同时会释放同步监视器的调用
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }

                }else{
                    break;
                }
            }
        }
    }
}


package Test3;

public class PrintNumberTest {
    public static void main(String[] args) {
        PrintNumber p = new PrintNumber();
        Thread t1 = new Thread(p,"线程1");
        Thread t2 = new Thread(p,"线程2");
        t1.start();
        t2.start();
    }

}

5 wait()和sleep()的区别：

  • 相同点:一旦执行，当前线程都会进入堵塞状态

  • 不同点：

    1 声明的位置：wait():声明在Object类中

    ​ sleep():声明在Thread类中，静态的

    2 使用的场景不同：wait():只能使用在同步代码块和同步方法中

    ​ sleep():可以在任何需要的场景

    3 使用在同步代码块和同步方法中：

    wait():一旦执行，会释放同步监视器

    sleep():一旦执行，不会释放同步监视器

    4 结束堵塞的方式：

    wait():到达指定时间自动结束堵塞或通过被notify唤醒，结束堵塞

    sleep():到达指定时间自动结束堵塞

烦躁的黄色汉堡
关注
Java多线程基础知识
gldzzznb的博客
04-10 3361
这是我再次学习多线程知识的一个总结，对于刚刚接触的学习者是比较友好易懂的，便于快速的理解和掌握。
多线程基础知识点
weixin_48903815的博客
03-01 2037
一、线程与进程 进程：进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统就会创建一个进程，并为它分配资源，然后把该进程放入进程就绪队列，进程调度器选中它的时候就会为它分配CPU时间，程序开始真正运行。 线程：线程是一条执行路径，是程序执行时的最小单位，它是进程的一个执行流，是CPU调度和分派的基本单位，一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。线程由CPU独立调度执行，在多CPU环境下就允许多个线程同时运行。同样多线程也可以实
JAVA面试八股文之多线程基础知识
热门推荐
m0_59230408的博客
12-16 2万+
操作系统中有一个组件叫做任务调度器，将cpu的时间片（windows下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于cpu在线程间（时间片很短）的切换非常快，人类感觉是同时运行的。进程就是用来加载指令、管理内存、管理 IO 的。家庭主妇雇了个保姆，她们一起这些事，这时既有并发，也有并行（这时会产生竞争，例如锅只有一口，一个人用锅时，另一个人就得等待）雇了3个保姆，一个专做饭、一个专打扫卫生、一个专喂奶，互不干扰，这时是并行。()方法在一个线程中启动另一个线程，另外一个线程完成该线程继续执行。
【操作系统】多线程基础知识
qq_68993495的博客
10-08 3323
操作系统之多线程基础知识汇总，很想对你所帮助！喜欢就请三连支持吧，谢谢~
多线程基础知识以及常用方法
weixin_43874591的博客
11-19 3866
多线程 一、什么是进程 进程是系统进行资源分配和调用的独立单元，每一个进程都有它的独立内存空间和系统资源。 二、单进程操作系统和多进程操作系统的区别 单进程操作系统 dos：一次只能执行单个任务 多进程操作系统 Windows：一次可以执行多个任务 三、系统在同一个时刻可以执行多个任务吗？ 理论上，同一个时刻可以执行多个任务。 因为CPU切换比较快，有的进程正在运行，有的进程正在争抢资源，有的进程正在退出资源 四、什么是线程，理解线程和进程的关系 什么是线程？ 线程是进程里面的一条执行路径，每
Java多线程的知识点
weixin_59796310的博客
05-28 4902
Java多线程的知识点
java多线程基础知识
TimeTDIT的博客
09-12 7932
  在不是多线程的情况下，任务是一个一个执行的，然而当我们使用多线程的时候，cpu便允许单个程序创建多个并行执行的线程来完成各自的任务，这样也就可以提高CPU的利用率。来初步认识下java中的多线程：1、  java中的线程类继承自java.lang.Thread或者其子类，Thread的构造函数有四个：1、Thread();2、Thread(String name);3、Thread(Runna...
多线程基础知识之线程阻塞
chenglian9396418的博客
08-29 2098
1什么是线程阻塞？ 在某一时刻某一个线程在运行一段代码的时候，这时候另一个线程也需要运行，但是在运行过程中的那个线程执行完成之前，另一个线程是无法获取到CPU执行权的（调用sleep方法是进入到睡眠暂停状态，但是CPU执行权并没有交出去，而调用wait方法则是将CPU执行权交给另一个线程），...
多线程重点知识归纳总结。
yzh2776680982的博客
06-08 2032
一、线程相关概念 1、程序 程序是一个指令序列。是为完成特定任务、 用某种语言编写的一组指令的集合。简单的说:就是我们写的代码 它以某些程序设计语言编写，运行于某种目标结构体系上。打个比方，程序就如同以英语（程序设计语言）写作的文章，要让一个懂得英语的人（编译器）同时也会阅读这篇文章的人（结构体系）来阅读、理解、标记这篇文章。一般的，以英语文本为基础的计算机程序要经过编译、链接而成为人难以解读，但可轻易被计算机所解读的数字格式，然后放入运行。 2、进程 ............
工厂模式的介绍及实现
户伟伟的博客
09-25 96
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 165
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 821
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
智能BI平台项目
2302_79400545的博客
09-22 223
BI商业智能：数据可视化、报表可视化系统。
Android系统：系统架构
liufeismart2024的博客
09-23 493
Android的系统结构的设计混合了分层设计和分块设计。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值