五分钟让你学会Java线程

已于 2023-06-28 16:00:27 修改
阅读量66 收藏
点赞数
文章标签： java 开发语言 jvm
于 2023-06-05 00:14:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76614448/article/details/131021094
版权
本文详细介绍了Java中进程与线程的概念、区别，包括线程的组成、特点和创建方式。通过示例代码展示了如何创建和管理线程，以及线程状态。同时，讨论了多线程安全问题和解决方法，如使用`synchronized`关键字确保线程同步。
摘要由CSDN通过智能技术生成

目录：

1.1什么是进程？

1.2什么是线程？

1.3进程和线程的区别是什么？

1.4线程的组成

1.5线程的特点

1.6线程的创建方式

1.7创建线程

1.7.1获取和设置线程的名称

1.8举例演示（Idea）

1.9线程的状态

2.1 Thread类中常用的方法有哪些？

2.2多线程安全问题演示

2.3同步方式

 

 

技术细节：

1.1在学习线程之前我们先了解一下什么是进程：

23ac9366af1f4a65a81b66c6ad786edc.png

1.2那么什么是线程呢？线程和进程的区别又是什么呢？

b8f9305986ba4c8bacf9453f71387c76.png

 1.3线程和进程的区别

1. 进程是操作系统资源分配的基本单位，而线程是CPU的基本调度单位。


2. 一个程序运行后至少有一个线程。


3. 一个进程可以包含多个线程，但是至少需要有一个线程，否则这个进程是没有意义。


4. 进程间不能共享数据段地址，但是同进程的线程之间可以。

1.4线程的组成

*任何一个线程都具有基本的组成部分   
          CPU时间片: 操作系统（OS）会为每个线程分配执行时间  

           *运行数据:
                堆空间: 存储线程需要的对象，多个线程可以共享堆中的数据。
                栈空间:  存储线程需使用的局部变量，每个线程都拥有独立的栈。

            *线程的逻辑代码.

1.5线程的特点

1.线程抢占式执行

      *效率高

      *可防止单一线程长时间独占CPU

2.在单核 CPU 中，宏观上同时执行，微观上顺序执行

1.6线程的创建方式

1. 【继承Thread类，重写run方法】
2. 【实现Runnable接口】
3.  实现Callable接口

1.7创建线程

326e7c6a32ad40c9817f16fe04e53ad1.png

10ced8ccd1554a79b20bf6c5e3064d57.png

 1.7.1获取和设置线程名称

        *获取线程ID 和线程名称

                 * 在Thread的子类中调用this.getId()或this.getName()
                 * 使用Thread.currentThread().getId()和
                  Thread.currentThread().getName()

        *为线程起名

                *通过setName() 为线程起名字

package demo01;

import demo01.MyThread;
//主线程和下面的任务代码，也就是多线程，他们会随机获得时间片
public class Test01 {
    //主线程
    public static void main(String[] args) {
        //1.创建线程对象
        MyThread my = new MyThread();
        //为线程起名字；一定要在线程开启前起名字
        my.setName("线程A");
        //为线程设置优先级
        my.setPriority(Thread.MIN_PRIORITY);
        //2.启动线程----当获取cpu时间片，那么该线程就会执行run方法的任务代码
        my.start();
        //1.创建线程对象
        MyThread my1 = new MyThread();
        //为线程起名字；一定要在线程开启前起名字
        my1.setName("线程B");
        //为线程设置优先级
        my1.setPriority(Thread.MIN_PRIORITY);
        //2.启动线程----当获取cpu时间片，那么该线程就会执行run方法的任务代码
        my1.start();
        //主线程代码
        //主函数的线程名不能用getName拿到；正确方法是Thread.currentThread().getName();意思是获取当前线程
        //Thread.currentThread().getName();可以适应任意场景获取线程名
        for (int j = 0; j < 20; j++) {
            System.out.println(Thread.currentThread().getName()+"=========" + j);
        }
    }
}






package demo01;

public class MyThread extends Thread {//继承Thread
    //重写run方法：线程的执行任务
    public void run() {
        for (int i = 0; i < 20; i++) {
            //getName获取该线程的名字，getName这种方法只能适用于Thread的子类
            System.out.println(getName()+"===============" + i);
        }
    }
}


package demo03;

//以任务的形式实现线程
public class Test03 {
    public static void main(String[] args) {
        //线程任务类对象
        MyRunnable my = new MyRunnable();
        //把任务交给该线程，该线程就会执行自己的任务，而不是执行main的run方法
        //如果不把my交给t1，他就只会执行主函数main
        //构造函数有两个参，一个是任务，还有一个是名字可以给线程传进取个名字；线程a
        Thread t1 = new Thread(my, "线程a");//创建线程对象 Runable target；
        //启动线程
        t1.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("main=============" + i);

        }
    }
}







package demo03;
//该类不是线程类；他是一个线程任务类
public class MyRunnable implements Runnable {
    @Override
    //重写run方法：线程任务代码
    //这里不能用getName来拿到线成名称，因为实现的Runable接口里面没有那个方法
    public void run() {
        for (int i = 0; i <20;i++) {
            System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~~~~~~~~");
        }
    }
}

1.8举例演示

6678d0304ad4458b8058f528d192070e.png

package demo02;

public class Test02 {
    public static void main(String[] args) {
        TicketThread t1 = new TicketThread("窗口A");//线程名：窗口A
        TicketThread t2 = new TicketThread("窗口B");
        TicketThread t3 = new TicketThread("窗口C");
        TicketThread t4 = new TicketThread("窗口D");
        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }
}






package demo02;

public class TicketThread extends Thread {
    private  int ticket = 100;//票数
    //另外一种起线程名字的方法，通过有参构造
    public TicketThread(String name) {
        super(name);
    }
    public void run() {
        while(ticket>0){
            ticket--;
            System.out.println(Thread.currentThread().getName()+"卖了一张票;剩余："+ticket+"张");
        }
    }
}

27942d0a694c443ea5ebb936ff1dbc25.png

 示例第一种情况.

package demo04;

public class Test04 {
    public static void main(String[] args) {
        TicketTask task = new TicketTask();
        Thread t1 = new Thread(task,"窗口A");
        Thread t2 = new Thread(task,"窗口B");
        Thread t3 = new Thread(task,"窗口C");
        Thread t4 = new Thread(task,"窗口D");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}






package demo04;

public class TicketTask implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
        while(true) {
            if (ticket>0){
                ticket--;
                System.out.println(Thread.currentThread().getName() + " 卖了一张票；剩余： " + ticket+"张");
            }else {
                break;
            }
        }

    }
}

7f8349dcbe5f4e95be6b28f3682b3a99.png

这种情况会导致：

e67969cc1a87450186b75ce3bb438998.png

2.1 Thread类中常用的方法有哪些？

1.

701c9cbed2764353bfc54c54d8401907.png*sleep代表方法名。

*long millis 代表休眠时间 单位是毫秒。

代码演示

package demo05;

//他是一个线程类，他是继承的
public class MyThread extends Thread {//继承Thread
    //重写run方法：线程的执行任务
    public void run() {
        for (int i = 0; i < 20; i++) {
                //Thread.sleep(500);休眠方法；使用场景：演示代码执行时间超时
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //getName获取该线程的名字，getName这种方法只能适用于Thread的子类
            System.out.println(getName()+"===============" + i);
        }
    }
}




public class Test01 {
    //主线程
    public static void main(String[] args) {
        //1.创建线程对象
        MyThread my = new MyThread();

        //为线程起名字；一定要在线程开启前起名字
        my.setName("刘德华");

        //2.启动线程----当获取cpu时间片，那么该线程就会执行run方法的任务代码
        my.start();

        //主线程代码
        //主函数的线程名不能用getName拿到；正确方法是Thread.currentThread().getName();意思是获取当前线程
        //Thread.currentThread().getName();可以适应任意场景获取线程名
        for (int j = 0; j < 20; j++) {
            System.out.println(Thread.currentThread().getName()+"=========" + j);
        }
    }
}

685c9398756e440998c469b7296fa55d.png

2.

a9e2c885107f4fa4a6565b407090de40.png

package demo06;

public class MyThread extends Thread {//继承Thread
    //重写run方法：线程的执行任务
    public void run() {
        for (int i = 0; i < 20; i++) {
            Thread.yield();//使用这个方法线程AB交替的概率高
            //getName获取该线程的名字，getName这种方法只能适用于Thread的子类
            System.out.println(getName()+"===============" + i);
        }
    }
}





public class Test01 {
    //主线程
    public static void main(String[] args) {
        //1.创建线程对象
        MyThread my = new MyThread();
        //为线程起名字；一定要在线程开启前起名字
        my.setName("线程A");
      
        //2.启动线程----当获取cpu时间片，那么该线程就会执行run方法的任务代码
        my.start();
        //1.创建线程对象
        MyThread my1 = new MyThread();
        //为线程起名字；一定要在线程开启前起名字
        my1.setName("线程B");
        
        //2.启动线程----当获取cpu时间片，那么该线程就会执行run方法的任务代码
        my1.start();
        //主线程代码
        //主函数的线程名不能用getName拿到；正确方法是Thread.currentThread().getName();意思是获取当前线程
        //Thread.currentThread().getName();可以适应任意场景获取线程名
        for (int j = 0; j < 20; j++) {
            System.out.println(Thread.currentThread().getName()+"=========" + j);
        }
    }
}

 3.

003f56ee69e24a8db692732d76e9c6f4.png

package demo07;

import demo01.MyThread;

//主线程和下面的任务代码，也就是多线程，他们会随机获得时间片
public class Test01 {
    //主线程
    public static void main(String[] args) throws InterruptedException {
        //1.创建线程对象
        MyThread my = new MyThread();
        //为线程起名字；一定要在线程开启前起名字
        my.setName("线程A");

        //2.启动线程----当获取cpu时间片，那么该线程就会执行run方法的任务代码
        my.start();

      my.join();//A线程执行结束，在执行主线程main；A线程使用join进行插队
        for (int j = 0; j < 20; j++) {
            System.out.println("main=========" + j);
        }
    }
}




package demo07;

public class MyThread extends Thread {//继承Thread
    //重写run方法：线程的执行任务
    public void run() {
        for (int i = 0; i < 20; i++) {

            //getName获取该线程的名字，getName这种方法只能适用于Thread的子类
            System.out.println(getName()+"===============" + i);
        }
    }
}

 4.

26b65df412c24a42b9fec7538782a467.png

package demo01;

import demo01.MyThread;
//主线程和下面的任务代码，也就是多线程，他们会随机获得时间片
public class Test01 {
    //主线程
    public static void main(String[] args) {
        //1.创建线程对象
        MyThread my = new MyThread();
        //为线程起名字；一定要在线程开启前起名字
        my.setName("线程A");
        //为线程设置优先级
        my.setPriority(1);
        //2.启动线程----当获取cpu时间片，那么该线程就会执行run方法的任务代码
        my.start();
        //1.创建线程对象
        MyThread my1 = new MyThread();
        //为线程起名字；一定要在线程开启前起名字
        my1.setName("线程B");
        //为线程设置优先级
        my1.setPriority(10);
        //2.启动线程----当获取cpu时间片，那么该线程就会执行run方法的任务代码
        my1.start();
        //主线程代码
        //主函数的线程名不能用getName拿到；正确方法是Thread.currentThread().getName();意思是获取当前线程
        //Thread.currentThread().getName();可以适应任意场景获取线程名
        for (int j = 0; j < 20; j++) {
            System.out.println(Thread.currentThread().getName()+"=========" + j);
        }
    }
}





package demo01;

public class MyThread extends Thread {//继承Thread
    //重写run方法：线程的执行任务
    public void run() {
        for (int i = 0; i < 20; i++) {
            //getName获取该线程的名字，getName这种方法只能适用于Thread的子类
            System.out.println(getName()+"===============" + i);
        }
    }
}

 5.

a5e64899ec1b4c2e9c3642dfb68e57ea.png

296f715a7bdb4d11a4089d9ed8e399f7.png

把t1循环200下

e4d964ef4fe64fcc9b98700e0dda0232.png 设置为守护线程后只循环了54下

 2.2多线程安全问题演示

0f74ee18d97b4c22adb60754c69e6d9d.png

package demo08;

import java.util.ArrayList;
import java.util.Arrays;

public class Test05 {
    private static String arr [] = new String[3];
    private static int index=0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {//匿名内部类
            @Override
            public void run() {
                if (arr[index] == null) {
                    arr[index] = "hello";
                    index++;
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {//匿名内部类
            @Override
            public void run() {
                if (arr[index] == null) {
                    arr[index] = "world";
                    index++;
                }
            }
        });
        t1.start();
        t2.start();

        t1.join();
        t2.join();//必须让这两个线程进行插队，因为 System.out.println(Arrays.asList(arr));也是一个线程，不进行插队
        //主线程如果抢到事件片，会输出为空，因为前两个线程没有抢到事件片，没有往数组里添加内容
        System.out.println(Arrays.asList(arr));
    }
}

 *会出现这种情况

f1aa1328e06e4fc5b061e3b33132f8d2.png

*原因

 因为两个线程同时操作这个数组，当word进行添加时，还没有来得及放值 ，然后时间片到了，就进行了hello

2.3同步方式

概要：当前线程执行完之后，另外一个线程才能执行

094fa44d13d644488f858f75cfc0f0c3.png

错误演示：

 1.fc13f33b520949fda49b3ad6ce61e7ec.png

2.

b224f63f988b4dacbb12b571a9200849.png

3.

9843b25e918d4d128ac23f0e7164dee1.png

 正确演示：

 1.

package demo08;

import java.util.ArrayList;
import java.util.Arrays;

public class Test05 {
    private static String arr [] = new String[3];
    private static int index=0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {//匿名内部类
            @Override
            public void run() {
               synchronized (arr) {
                   if (arr[index] == null) {
                       arr[index] = "hello";
                       index++;
                   }
               }
            }
        });

        Thread t2 = new Thread(new Runnable() {//匿名内部类
            @Override
            public void run() {
                synchronized (arr) {
                    if (arr[index] == null) {
                        arr[index] = "world";
                        index++;
                    }
                }
            }
        });
        t1.start();
        t2.start();

        t1.join();
        t2.join();//必须让这两个线程进行插队，因为 System.out.println(Arrays.asList(arr));也是一个线程，不进行插队
        //主线程如果抢到事件片，会输出为空，因为前两个线程没有抢到事件片，没有往数组里添加内容
        System.out.println(Arrays.asList(arr));
    }
}

8f0b00666cf34ff089d2c419e2553005.png

 *输出结果不会只出现一个，另外一个没有执行的情况

2.

package demo04;

public class Test04 {
    public static void main(String[] args) {
        TicketTask task = new TicketTask();
        Thread t1 = new Thread(task,"窗口A");
        Thread t2 = new Thread(task,"窗口B");
        Thread t3 = new Thread(task,"窗口C");
        Thread t4 = new Thread(task,"窗口D");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}




package demo04;

public class TicketTask implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
        while(true) {
            synchronized (this) {//这里是同步代码块，必须获取（）里面的锁资源，才能进入同步代码块中
                //this可以当锁，因为 TicketTask task = new TicketTask();  只new了一个
                //这样就不会出现重卖，或者超卖的现象了
                //必须原子操作要求
                if (ticket>0){
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + " 卖了一张票；剩余： " + ticket+"张");
                }else {
                    break;
                }
            }
        }

    }
}

*输出结果不会出现重复

！！！补充

String：不可变，因为底层是final修饰的字符数组，所以不可变

StringBuilder：可变，线程不安全，效率高，底层方法没有加锁

StringBuffer：可变，线程安全，效率较低，底层方法加了锁

不喜欢吃西瓜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
一篇文章让你彻底学会Java多线程
创梦流浪人
04-21 1083
先了解几个基本的概念进程：进程是操作系统进行资源分配和调度的一个独立单位，每个进程都有自己独立的地址空间，即它们拥有各自独立的内存空间。进程间通信比较复杂，如通过管道、信号、套接字等方式。如果一个进程崩溃，通常情况下不会影响到其他进程，因为它们彼此隔离。（当程序开始执行时，操作系统会为其创建一个进程）线程：线程是进程中的一个执行流，它是CPU调度和分派的基本单位。一个进程可以包含多个线程，这些线程共享进程的资源，如内存和文件句柄。线程有自己的程序计数器、栈和局部变量，但是它们可以访问相同的全局变量。
java线程1-10-720p版本
02-13
通过这10个视频的学习，你将能够掌握Java线程的基本操作，了解线程的创建、执行、协作和管理，为实现高效的并发程序打下坚实的基础。在实际开发中，结合这些知识，你可以编写出更加健壮、性能优异的多线程应用程序。
【Collection】Java最常用的5种集合类（超详细分析）
m0_51634403的博客
09-10 133
List num = Arrays.asList(1, 2, 3); ArrayList nums = new ArrayList(num); //创建Iterator的实例 Iterator iterate = nums.iterator();
5分钟学会Java9-Java11的七大新特性
netease_im的博客
11-19 185
现在Java有多元化的发展趋势，既有JS又有C++还有C#的影子，不学习那是不行滴。 来来来，花5分钟看看Java9-Java11的七大新特性，还有代码样例。 Java11 发布了，然而很多公司还在用Java 8 ，这里简单介绍一下 Java 9 -11 引入的新语法和API。 本地变量类型推断 Java 10 就已经引入了新关键词var，该关键词可以在声明局部变量的时候替换类型信息。本地...
5分钟系列~学会编程
猿医ˉ生
06-22 2403
5分钟系列~学会编程 0、前言 5分钟系列 ~ 学会编程： 以下为超链接，请各位猿友查阅 ！！ 一、java系列 1、5分钟学会java获取数据库列名、别名、类型等信息 2、5分钟学会java获取当天、昨天、本周、上周、本月、上...
万字图解Java多线程
热门推荐
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
10 分钟学会使用 Java 多线程
伍六七的博客
11-14 304
有些情况，我们需要做到资源隔离，比如上面使用 进行 IO 操作，我们需要自定义线程池，那我们怎么定义呢？
5分钟学会3种Java创建多线程任务的方法
互相学习
01-08 475
本文将介绍Java几种基本的多线程用法，并简单分析各个方法的优缺点。 方法1：继承Thread类 我们可以创建一个自己的类，并通过继承Thread类并重写 void run() 方法。 // 创建自己的类并继承Thread class MyThread extends Thread { private String name; public MyThread(String...
Java线程安全
m0_74837900的博客
01-29 880
注意同步构造器的唯一性 ，（特别注意this在继承Thread时不能用）同步方法 在继承Thread类模式下，同步方法用static修饰，同步代码块不能用this, 这是保证同步监视器唯一性。
Java多线程
qq_34471880的博客
03-14 1007
Java多进程,多线程编程,如何创建线程,线程启动中断等待,了解各种线程状态,线程安全以及如何解决线程安全问题,锁的作用,以及如何加锁,了解死锁怎么出现,如何解决死锁问题
【Java】室友打一把王者就学会了多线程
weixin_60719453的博客
12-09 4万+
一、前言 线程可能听起来有点难，其实也是非常好理解的，咱们以游戏姿势进入。 二、线程和进程 进程：是正在运行的，进程是资源分配的最小单位。 线程：是cpu调度的最小单位（线程依赖于进程）。 上面可能有些难懂，打个比喻，好比你打一把王者农药(其实我不玩哈doge)，进程比作是你开的 那一把游戏，线程比作成每个玩家所选的英雄或者是游戏中的水晶野怪等之类的。带着这个 比喻来理解进程和线程的一些关系。 一个进程有多个线程就叫多线程。是不是感觉非常好理解。 ❤1.线程在进程下进行 1.
Java多线程程序设计
02-19
1. **创建Java线程对象**：学习如何通过继承`Thread`类或实现`Runnable`接口来创建新的线程。 2. **改变线程状态**：了解线程生命周期中的不同状态（新建、就绪、运行、阻塞和终止），并掌握如何通过`start()`、`...
7.多线程__阶乘_java_阶乘运算_西南科技大学_多线程_
09-30
在编程领域，多线程是一种常见且重要的技术，特别是在Java这样的多线程支持良好的语言中。...通过实践，他们将学会如何在Java中有效地管理线程，提高程序的并发性能，这对于开发高效、响应迅速的应用程序至关重要。
100个java实例，让你轻松学会java编程
05-23
本资源“100个Java实例，让你轻松学会Java编程”旨在通过实际操作来帮助初学者深入理解Java的核心概念和技术。下面，我们将详细探讨这些实例中可能涵盖的关键知识点。 1. **基础语法**：学习任何编程语言的第一步都...
Java并发编程进程和线程之由来Java开发Java经验技
11-22
Java并发编程是Java开发中的重要领域，涉及到进程与线程的概念，这两个概念是理解多任务执行的基础。在现代计算机系统中，进程和线程被广泛用于实现高效的资源管理和任务调度。 **1. 进程** 进程是操作系统分配...
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 1961
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 2328
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 2541
linux上datax 安装以及使用
操作系统原子操作
最新发布
zzt_is_me的博客
08-28 755
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值