多线程基础-01

已于 2022-11-16 17:26:19 修改
阅读量168 收藏 1
点赞数 1
分类专栏： Java基础 文章标签： java 多线程
于 2022-02-12 18:24:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44535022/article/details/122900054
版权

文章目录

1.线程简介

普通方法调用和多线程

在这里插入图片描述

程序|进程|线程

程序（Program）：包含多个进程。

进程（Process）：在操作系统中，运行的程序就是进程，比如你的QQ，播放器，游戏，IDE等等…

线程（Thread）：一个进程可以有多个线程，如视频中同时听声音、看图像、看弹幕等。

Process 和 Thread

  1. 说起进程（Process），就不得不说下程序（Program）。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
  2. 而进程（Process）则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位。
  3. 通常在一个进程（Process）中可以包含若干个线程（Thread），当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位.
`注意`：
很多个多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。

核心概念

  • 线程就是独立的执行路径。
    – 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程(main()函数)、GC线程(也称之为守护线程--是jvm创建的)。
  • main()称之为主线程，为系统的入口，用于执行整个程序。
  • 在一个进程中，如果开辟了多个线程，线程的运行由调度器（也就是cpu）安排调度，调度器（cpu）是与操作系统紧密相关的，先后顺序是不能人为的干预的。
  • 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制。
  • 线程会带来额外的开销，如cpu调度时间，并发控制开销。
  • 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

2.线程实现（重点）

线程创建

三种创建方式：
在这里插入图片描述

Thread

提示：查看JDk帮助文档

网盘下载JDk帮助文档：
链接：https://pan.baidu.com/s/1BWt4_j70nDVksYLyzh0dYA 
提取码：qgq8

(1)创建线程方式一：继承Thread类

  • 自定义线程类继承Thread类
  • 重写run()方法，编写线程执行体
  • 创建线程对象，调*start()方法启动线程

代码实现：

/**
    创建线程方式一：
        1.继承 Thread 类
        2.重写 run() 方法
        3.调用start 开启线程
 */
public class TestThread1 extends Thread {

    @Override
    public void run() {

        // run() 方法线程体
        for (int i = 0; i < 200; i++) {
            System.out.println("run方法体正在执行---------"+i);
        }

    }

    public static void main(String[] args) {

        // 创建一个线程对象
        TestThread1 testThread1 = new TestThread1();

        // 调用start() 方法开启线程
        testThread1.start();
        // 调用run()方法
//        testThread1.run();

        // 对比start()方法 和 run()方法的区别：
        // start()方法：开启后线程执行顺序是随机的--也就是同时执行的！
        // run()方法：开启后线程执行顺序是顺序的


        // main() 主线程
        for (int i = 0; i < 200; i++) {
            System.out.println("main()主线程正在执行+++++++"+i);
        }
        
    }
}

执行结果

......
run方法体正在执行---------85
main()主线程正在执行+++++++187
run方法体正在执行---------86
run方法体正在执行---------87
main()主线程正在执行+++++++188
main()主线程正在执行+++++++189
main()主线程正在执行+++++++190
main()主线程正在执行+++++++191
main()主线程正在执行+++++++192
main()主线程正在执行+++++++193
main()主线程正在执行+++++++194
run方法体正在执行---------88
main()主线程正在执行+++++++195
main()主线程正在执行+++++++196
main()主线程正在执行+++++++197
main()主线程正在执行+++++++198
main()主线程正在执行+++++++199
run方法体正在执行---------89
run方法体正在执行---------90
......

总结

`总结`：
	注意1：线程开启不一定立即执行，是由CPU调度执行
	注意2：不能调用run()方法，而是调用start()方法

代码实现案例：

下载图片的例子:

步骤一：准备工作-引入需要的依赖

如果是自己单独引入的依赖包，是没有添加到本地库中的，需要创建文件夹lib，然后将依赖包添加进来，但是直接引入的依赖包是不能直接来使用的。右键Add as Library...将依赖包添加到库中。

步骤二：进行代码编写

代码实操

// 练习Thread，实现多线程同步下载图片
public class TestThread2 extends Thread{

    private String url;// 网络图片地址
    private String name;// 保存的文件名

    // 构造器
    public TestThread2(String url,String name){
        this.url = url;
        this.name = name;
    }

    // 下载图片线程的执行体
    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载的文件名为：" + name);
    }


    public static void main(String[] args) {
        // 图片路径在网上随便找一个
        TestThread2 t1 = new TestThread2("https://img-blog.csdnimg.cn/48a7e900dbbe409585fe118a293f74df.png","1.jpg");
        TestThread2 t2 = new TestThread2("https://img-blog.csdnimg.cn/48a7e900dbbe409585fe118a293f74df.png","2.jpg");
        TestThread2 t3 = new TestThread2("https://img-blog.csdnimg.cn/48a7e900dbbe409585fe118a293f74df.png","3 .jpg");

        // 启动线程
        t1.start();
        t2.start();
        t3.start();

    }

}

// 下载器
class WebDownloader{

    // 下载方法
    public void downloader(String url,String name){
        // 使用Commons-io包中的方法进行操作
        try {
            // FileUtils-文件工具
            FileUtils.copyURLToFile(new URL(url),new File(name));// 将网页地址拷贝成文件
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("Io异常，download方法异常！");
        }
    }
}

执行结果

下载的文件名为：2.jpg
下载的文件名为：3.jpg
下载的文件名为：1.jpg

(2)创建线程方式二：实现Runnable()接口

  • 定义MyRunnable类实现Runnable()接口
  • 实现run()方法，编写线程执行体
  • 创建线程对象，调用start()方法，启动线程

*推荐使用Runnable对象，因为java单继承的局限性

代码实现

/**
    创建线程方式2：
        1.实现runnable 接口
        2.重写run()方法
        3.执行线程需要丢入Runnable()接口实现类中
        4.调用start()方法启动线程
*/

public class TestThread3 implements Runnable{

    @Override
    public void run() {

        // run() 方法线程体
        for (int i = 0; i < 200; i++) {
            System.out.println("Runnable()接口的run方法体正在执行---------"+i);
        }

    }

    public static void main(String[] args) {
        // 创建Runnable()接口的实现类对象
        TestThread3 testThread3 = new TestThread3();

        //创建线程对象,通过线程对象来开启我们的线程：俗称代理【[点击学习静态代理](https://blog.csdn.net/weixin_44535022/article/details/122907302)】
        /*Thread thread = new Thread(testThread3);
        thread.start();*/
        // 简写代码为：
        new Thread(testThread3).start();

        // main() 主线程
        for (int i = 0; i < 200; i++) {
            System.out.println("main()主线程正在执行+++++++"+i);
        }

    }
}

执行结果

......
Runnable()接口的run方法体正在执行---------174
main()主线程正在执行+++++++124
main()主线程正在执行+++++++125
main()主线程正在执行+++++++126
main()主线程正在执行+++++++127
Runnable()接口的run方法体正在执行---------175
Runnable()接口的run方法体正在执行---------176
Runnable()接口的run方法体正在执行---------177
Runnable()接口的run方法体正在执行---------178
main()主线程正在执行+++++++128
Runnable()接口的run方法体正在执行---------179
main()主线程正在执行+++++++129
Runnable()接口的run方法体正在执行---------180
......

使用Runnable()接口实现上述案例一：利用多线程下载网络图片

// 练习Runnable，实现多线程同步下载图片
public class TestThread4 implements Runnable{

    private String url;// 网络图片地址
    private String name;// 保存的文件名

    // 构造器
    public TestThread4(String url,String name){
        this.url = url;
        this.name = name;
    }

    // 下载图片线程的执行体
    @Override
    public void run() {
        WebDownloader1 webDownloader1 = new WebDownloader1();
        webDownloader1.downloader(url,name);
        System.out.println("下载的文件名为：" + name);
    }


    public static void main(String[] args) {
        // 图片路径在网上随便找一个
        TestThread4 t1 = new TestThread4("https://img-blog.csdnimg.cn/48a7e900dbbe409585fe118a293f74df.png","1.jpg");
        TestThread4 t2 = new TestThread4("https://img-blog.csdnimg.cn/48a7e900dbbe409585fe118a293f74df.png","2.jpg");
        TestThread4 t3 = new TestThread4("https://img-blog.csdnimg.cn/48a7e900dbbe409585fe118a293f74df.png","3.jpg");

        // 启动线程
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();

    }

}

// 下载器
class WebDownloader1{

    // 下载方法
    public void downloader(String url,String name){
        // 使用Commons-io包中的方法进行操作
        try {
            // FileUtils-文件工具
            FileUtils.copyURLToFile(new URL(url),new File(name));// 将网页地址拷贝成文件
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("Io异常，download方法异常！");
        }

    }
}

执行结果

下载的文件名为：2.jpg
下载的文件名为：3.jpg
下载的文件名为：1.jpg

总结继承Thread类和实现Runnable()接口的区别：

  1. 继承Thread类：

    • 子类继承Thread类具备多线程能力
    • 启动线程：子类对象.start()
    • 不建议使用：避免OOP单继承局限性

  2. 实现Runnable()接口：

    • 实现Runnable()接口具备多线程能力
    • 启动线程：传入目标对象+Thread对象.start()
    • 推荐使用：避免单继承局限性，灵活多方便，方便同一个对象被多个线程使用。

例:

// 一份资源
TestThread4 t1 = new TestThread4();
        
// 多个代理
new Thread(t1,"张三").start();
new Thread(t2,"李四").start();
new Thread(t3,"老师").start();

*备注：

单继承局限性：在Java中一个类只能使用extends继承一个父类.

也就是在实际开发中多使用实现接口类开发,继承类的操作尽量减少。

如何实现多个线程操作同一个对象？

// 多个线程同时操作同一个对象
// 买火车票的例子

public class TestThread5 implements Runnable{

    // 票数量
    int ticketNums = 10;


    @Override
    public void run() {
        while (true) {
            if (ticketNums <= 0) {
                break;
            }

            // 模拟延时
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + ">>>拿到了第"+ (ticketNums--) +"票");
        }
    }

    public static void main(String[] args) {
        // 一份资源
        TestThread5 ticket = new TestThread5();

        // 多份线程
        new Thread(ticket,"张三").start();//给线程起名字
        new Thread(ticket,"李四").start();
        new Thread(ticket,"王五").start();
    }
}

执行结果

李四>>>拿到了第10票
张三>>>拿到了第9票
王五>>>拿到了第8票
王五>>>拿到了第7票
张三>>>拿到了第6票
李四>>>拿到了第6票
王五>>>拿到了第5票
李四>>>拿到了第5票
张三>>>拿到了第5票
张三>>>拿到了第4票
李四>>>拿到了第4票
王五>>>拿到了第4票
张三>>>拿到了第2票
王五>>>拿到了第3票
李四>>>拿到了第1票
张三>>>拿到了第0票


/**
    发现问题：
        多个线程操作同一个资源的情况下，线程不安全，出现脏数据
    如何解决呢？
    	需要线程同步才能解决！【点击查看线程同步】
 */

练习：龟兔赛跑

步骤如下：

  1. 首先来个赛道距离，然后要离重点越来越近
  2. 判断比赛是否结束
  3. 打印出胜利者
  4. 龟兔赛跑开始
  5. 故事中是乌龟赢的，兔子需要睡觉，所以需要模拟兔子睡觉
  6. 终于，乌龟赢得比赛
// 模拟龟兔赛跑
public class Race implements Runnable{

    // 胜利者
    private static String winner;


    @Override
    public void run() {
        for (int i = 0; i <= 50; i++) {

            // 模拟兔子休息
            if (Thread.currentThread().getName().equals("兔子") && i%10==0) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            // 判断比赛是否结束
            boolean flag = gameOver(i);
            // 如果比赛结束了，就停止程序
            if (flag) {
                break;
            }
            System.out.println(Thread.currentThread().getName() + ">>>跑了"+ i +"步");
        }
    }

    // 判断是否完成比赛
    private boolean gameOver(int steps){
        //判断是否有胜利者
        if (winner != null){//存在胜利者
            return true;
        } else if (steps >= 50) {
            winner = Thread.currentThread().getName();
            System.out.println("winner is " + winner);
            return true;
        } else {
            return false;
        }
    }


    public static void main(String[] args) {
        Race race = new Race();

        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

执行结果

乌龟>>>跑了0步
兔子>>>跑了0步
乌龟>>>跑了1步
兔子>>>跑了1步
乌龟>>>跑了3步
兔子>>>跑了3步
......
乌龟>>>跑了49步
兔子>>>跑了11步
winner is 乌龟

(3)创建线程方式三：实现Callable<返回值>()接口

  1. 实现Callable<返回值>()接口，需要返回值类型
  2. 重写call方法，需要抛出异常
  3. 创建目标对象
  4. 开启执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
  5. 提交执行：Future<Boolean> result1 = ser.submit(t1);
  6. 获取结果：boolean b1 = result1.get();
  7. 关闭服务：ser.shutdownNow();

练习：继续使用上述案例–下载图片案例

// 实现Callable<返回值>()接口--实现多线程下载图片
public class TestCallable implements Callable<Boolean> {//<返回值类型>

    private String url;// 网络图片地址
    private String name;// 保存的文件名

    // 构造器
    public TestCallable(String url,String name){// 构造器是对本类的构造,名字必须一致
        this.url = url;
        this.name = name;
    }

    // 下载图片线程的执行体
    @Override
    public Boolean call() {
        WebDownloader3 webDownloader = new WebDownloader3();
        webDownloader.downloader(url,name);
        System.out.println("下载的文件名为：" + name);
        return true;
    }


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 图片路径在网上随便找一个
        TestCallable t1 = new TestCallable("https://img-blog.csdnimg.cn/48a7e900dbbe409585fe118a293f74df.png","1.jpg");
        TestCallable t2 = new TestCallable("https://img-blog.csdnimg.cn/48a7e900dbbe409585fe118a293f74df.png","2.jpg");
        TestCallable t3 = new TestCallable("https://img-blog.csdnimg.cn/48a7e900dbbe409585fe118a293f74df.png","3.jpg");

        /*
            1. 开启执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
            2. 提交执行：Future<Boolean> result1 = ser.submit(t1);
            3. 获取结果：boolean b1 = result1.get();
            4. 关闭服务：ser.shutdownNow();
         */


        // (1)创建执行服务：【ExecutorService与Executors后面详细讲解】
        ExecutorService ser = Executors.newFixedThreadPool(3);

        // (2)提交执行
        Future<Boolean> result1 = ser.submit(t1);
        Future<Boolean> result2 = ser.submit(t2);
        Future<Boolean> result3 = ser.submit(t3);

        // (3)获取结果
        boolean b1 = result1.get();
        boolean b2 = result2.get();
        boolean b3 = result3.get();

        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);

        // (4)关闭服务
        ser.shutdownNow();
    }
}

// 下载器
class WebDownloader3{

    // 下载方法
    public void downloader(String url,String name){
        // 使用Commons-io包中的方法进行操作
        try {
            // FileUtils-文件工具
            FileUtils.copyURLToFile(new URL(url),new File(name));// 将网页地址拷贝成文件
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("Io异常，download方法异常！");
        }
    }
}

执行结果

下载的文件名为：3.jpg
下载的文件名为：2.jpg
下载的文件名为：1.jpg
true
true
true
倾·浪漫老爷#Yolo-Qing
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程基础-使用多线程
cgmx551的博客
03-08 1899
线程:程序执行流的最小单元【可以理解为：进程中独立运行的子任务】。 多线程优点:最大限度的利用CPU的空闲时间来处理其他任务。 |-目录 |  创建线程 |  线程运行结果与执行顺序无关 |  线程实例变量与安全问题 |  停止线程 |  线程优先级 |  守护线程 |  线程让步 -创建线程 线程的创建方式:  1.继承Thread类 public class ThreadCreateDemo1 { public static void main(String[] args) { ...
Java多线程基础-01、数组概述.rar
11-20
Java多线程基础-01、数组概述.rar
C语言多线程基础-01-线程的创建与销毁
CycloneKid的博客
11-01 1万+
一.线程创建首先要关联头文件Window.h，需要使用Windows系统的底层方法1.1 线程创建演示：//定义一个方法，弹出一个消息框 //该方法返回值为DWORD WINAPI类型，参数为一个空指针 DWORD WINAPI run(void * p) { MessageBox(0, "多线程测试", "信息", 0); }//main方法中开启线程 int main(void) {
C#高级--多线程详解
热门推荐
李宥的博客
10-03 4万+
C#高级–多线程详解 零、文章目录 一、什么是多线程 1、进程 当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。 而一个进程又是由多个线程所组成的。 2、线程 线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。 3、句柄 句柄是Windows系统中对象或实例的标识，这些对象包括模块、应用程序实例、窗口、控制、位图、GDI对象、资源、文件等。 4、多线程 （1）多线程概念 多线程是指程序中
Python 多线程编程-01-threading 模块初识
一分耕耘一分收获
02-10 2269
1. 多线程基础知识 1.1 进程和线程的定义与区别？ 进程是一个执行中程序，每一个进程都有自己的地址空间、内存、数据栈以及其他用于跟踪执行的辅助数据。操作系统管理其上面的所有进程，并为这些进程合理的安排时间。一个进程也可以通过 fork 或者 spawn 新的进程来执行其他任务。进程之间通过 IPC 进行通信。 进程的相关知识，可以看我的这个专栏：操作系统_一分耕耘一分收获-CSDN博客 线程和进程类似，但是它是在进程下工作的，一个进程可能拥有多个线程，彼此之间享有共同的上下文或者说数据空间。
Java基础 -- 多线程的使用01
百世经纶『一页書』
01-26 8153
一文详解java 多线程的使用
【多线程系列-01】深入理解进程、线程和CPU之间的关系
zhenghuishengq的博客
07-14 1万+
深入理解进程，线程和cpu之间的关系
Java多线程基础
♾️
12-07 2143
多线程基础 回顾 1 File类：表示一个文件或文件夹 表示文件: 创建 createNewFile(); 删除 delete(); deleteOnExit(); 存在性判断 exists(); canExecute() canRead() canWrite() getAbsoluatePath(); getParent(); getName(); ...
多线程01---多线程基础
人的梦想是不会终结的
08-07 1013
1.进程和线程1.进程什么是进程 进程是指在系统中正在运行的一个应用程序 每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内 比如同时打开迅雷、Xcode，系统就会分别启动2个进程 通过“活动监视器”可以查看Mac系统中所开启的进程2.线程什么是线程 1个进程要想执行任务，必须得有线程（每1个进程至少要有1条线程） 一个进程（程序）的所有任务都在线程中执行 比如使用酷狗播放音乐、
多线程---并发容器的使用
意田天的博客
08-13 1万+
多线程---并发容器的使用1. 容器概览2. 容器的使用1. Map1. HashTable2. HashMap3. SynchronizedHashMap4. ConcurrentHashMap2. Collection1. ArrayList2. Vector3. LinkedList4. ConcurrentLinkedQueue3. 并发容器的使用1. ConcurrentHashMap2. CopyOnWriteArrayList3. ConcurrentLinkedQueue4. LinkedB
多线程day1-1
weixin_43695211的博客
05-28 1229
多线程 创建多线程方式： Thread public class ThreadTest01 extends Thread{ private String url; private String name; public ThreadTest01(String url,String name){ this.url=url; this.name=name; } //多线程执行体 @Override ..
Java多线程基础-优秀程序员
04-10
源码简介01_串行与并发02_进程与线程"03线程寿命04.线程开发05_线程命名06_线程休眠07_线程优先级08_线程礼貌09_关键资源问题关键../等待...源码详情01_串行与并发02_进程与线程"03线程的生命04.线程的开辟05_线程的...
JAVA多线程入门基础知识
02-22
必知必会的多线程入门基础知识
01大数据面试复习----Java基础---集合类、多线程、JVM.zip
09-30
01大数据面试复习----Java基础---集合类、多线程、JVM.zip
【IT十八掌徐培成】Java基础第08天-01.多线程-yield.zip
08-07
【IT十八掌徐培成】Java基础第08天-01.多线程-yield.zip
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 892
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 900
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1209
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 672
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
多进程多线程--图形界面聊天室
10-28
多进程多线程--图形界面聊天室是一种基于socket(TCP)通信的应用程序，它可以实现多个用户之间的实时聊天。在该应用程序中，使用了多进程和多线程技术，其中一个进程负责终端操作，另一个进程负责图形化界面操作，两...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值