Java多线程初学 最全最强

最新推荐文章于 2024-04-02 12:49:51 发布
最新推荐文章于 2024-04-02 12:49:51 发布
阅读量199 收藏 1
点赞数
分类专栏： Java 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35217284/article/details/108718153
版权

多线程概述

线程与进程

在一开始学习多线程时，我们行得学习什么是进程，线程与进程的关系。

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程：
是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程。线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

线程调度

我们可能会以为线程会是一起同时执行的，其实并不是。cpu在同一时间其实只能做一件事儿~ 所以CPU来换切换运行多个进程，来制造他们是在同时运行的假象。

线程有两个调度机制：

1、分时调度

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

2、抢占式调度

优先让优先级高的线程使用CPU，如果线程优先级一样，则随机让一个线程优先使用（线程随机性）。Java使用的是抢占式调度。

*多线程的作用：*不能提高程序的运行速度，但能提高程序的运行效率，让CPU使用率更高。

同步与异步

同步：排队执行，效率低，但是安全。
异步：同时执行，效率高，但是数据不安全。

理解：在同步执行的时候，在一个线程干完了他的事儿，下一个线程才能来干。如果是异步执行，比如线程A知道了一个变量是10，但是下一秒线程B来把这个变量改成了20，这就造成了数据安全问题。

并发与并行

并发：指两个或多个事件在 同一时间段 里发生
并行：指两个或多个事件在 同一时刻 发生

继承Thread

一个类继承了Thread类就成为了线程类，在里面重写的run方法里写的代码就是线程一个执行路径。不过线程想要触发，得用start()方法来触发。

//run是线程要执行的任务方法
public class MyThread extends Thread{
    @Override
    public void run() {
        
    }
}

我们可以写几行代码验证一下线程的随机性

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("MyThread:"+i);
        }
    }

    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        myThread.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("main:"+i);
        }
    }
}

结果：
main:0
MyThread:0
main:1
MyThread:1
main:2
MyThread:2
main:3
MyThread:3
main:4
MyThread:4
main:5
MyThread:5
MyThread:6
main:6
MyThread:7
main:7
MyThread:8
main:8
MyThread:9
main:9

可以看到MyThread:6抢在了main:6的前面。可验证了线程随机性。

每一个线程都拥有自己的栈空间，但是都共同拥有一个堆内存。

实现Runnable接口

直接上代码：

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("这里是Runnable接口里的run方法");
    }
}

用Thread来使用它

MyRunnable r=new MyRunnable();
    Thread t=new Thread(r);
    t.start();

使用Runnable接口的好处：
1、通过创建任务，然后给线程分配的方式来实现的多线程，更适合多个线程同时执行相同任务的情况。
2、可以避免单继承带来的局限性。
3、任务与线程本身是分离的，提高了程序的健壮性。
4、线程池技术，接受Runnable类型的任务，不接受Thread类型的线程。

通过匿名内部类实现线程
 		new Thread(){
            @Override
            public void run() {
                System.out.println("通过匿名内部类实现线程");
            }
        }.start();
线程的停止

以前用stop()方法，现已过时。stop方法会直接把线程停止掉，这会导致资源不会被释放一直在占用。现在一般用消息通知线程让线程自己停止。比如：一个i变量，在他从1变为0的时候，线程自己检测到值的改变，则自己终止。

线程的休眠

sleep()方法

//每隔1秒打印一个数
for(int i=0;i<10;i++){
	System.out.println(i);
	Thread.sleep(1000);//这里传的是毫秒
}
守护线程与用户线程

用户线程可以自己决定自己什么时候结束。如果所有的用户线程都已经结束，守护线程则自动关闭。
设置守护线程代码：t.setDaemon(true);

设置和获取线程名称
//获取线程名称
Thread.currentThread().getName();
//设置线程名称
new Thread(new MyRunnable(),"Name1").start();
线程阻塞

所有消耗时间的操作都可以称为线程阻塞。比如：文件操作，控制台等待用户输入等。

线程中断

如果想要线程中断，可以在线程里的wait()、sleep()、interrupted()上加上try catch并抛出InterruptedException异常，这里的异常在检测到中断标志的时候触发。我们可以在触发时return run()方法，即可以结束线程。 我们可以调用interrupt()方法给线程标记中断

demo代码：

Thread t=new Thread(new MyRunnable());
        t.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("main："+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        t.interrupt();//标记中断

    }

    static class MyRunnable implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println("thread:"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("检测到中断标记，中断线程");
                    return;
                }
            }
        }
    }

线程t里每隔1秒打印到10，不过main方法里每隔1秒打印到5的时候就标记了中断到线程t里，这时候线程t打印到5就会结束掉。

打印结果：

main：0
thread:0
thread:1
main：1
main：2
thread:2
main：3
thread:3
thread:4
main：4
thread:5
检测到中断标记，中断线程

线程安全问题

先上Demo


public class ThreadSafe {
    public static void main(String[] args) {
        
        MyRunnable r=new MyRunnable();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
    }

    static class MyRunnable implements Runnable{
        private int i=10;
        @Override
        public void run() {
            while (i>0){
                System.out.println("正在出票。。。");
                i--;
                System.out.println("当前剩余票数："+i);
            }

        }
    }
}

这里我开了三个线程同时去出票。按道理到0的时候就不会出票。但是我们来看看运行结果：
正在出票。。。
正在出票。。。
正在出票。。。
当前剩余票数：7
正在出票。。。
当前剩余票数：8
正在出票。。。
当前剩余票数：9
正在出票。。。
当前剩余票数：5
当前剩余票数：6
正在出票。。。
当前剩余票数：3
正在出票。。。
当前剩余票数：2
当前剩余票数：4
正在出票。。。
当前剩余票数：1
正在出票。。。
正在出票。。。
正在出票。。。
当前剩余票数：-1
当前剩余票数：0
当前剩余票数：-2

这里我们看到最后剩余票数到了-1、-2。这就是线程安全的问题。可能在i还在1的时候三个线程同时进入循环出票。

解决方案

1、同步代码块

格式：

synchronized(锁对象){

}

上代码：

static class MyRunnable implements Runnable{
        private int i=10;
        Object o=new Object();
        @Override
        public void run() {
            while (true){
                synchronized (o) {
                    if (i > 0) {
                        System.out.println("正在出票。。。");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        i--;
                        System.out.println(Thread.currentThread().getName()+"当前剩余票数：" + i);
                    } else {
                        break;
                    }
                }
            }

        }
    }

这里我把要避免多个线程同时执行的代码放在了synchronized里，里面传了一个Object的o对象，在这段代码时的代码被某个线程执行时，会在o里进行标记，当其它线程想要执行这里面的代码时，会发现o里有标志就会等待。当某个线程执行结果时会把o里的标记清除。这时候所有线程又会进行争抢

来看一下运行结果：
正在出票。。。
Thread-0当前剩余票数：9
正在出票。。。
Thread-0当前剩余票数：8
正在出票。。。
Thread-0当前剩余票数：7
正在出票。。。
Thread-0当前剩余票数：6
正在出票。。。
Thread-2当前剩余票数：5
正在出票。。。
Thread-2当前剩余票数：4
正在出票。。。
Thread-2当前剩余票数：3
正在出票。。。
Thread-2当前剩余票数：2
正在出票。。。
Thread-2当前剩余票数：1
正在出票。。。
Thread-2当前剩余票数：0

我们看到现在就不会出现同时抢一张票的情况了。而且当一个线程抢到了的时候再次抢到的机率很大。我们称之为：回首掏~~~~~

2、同步方法

老规矩，先上代码

static class MyRunnable implements Runnable{
        private int i=10;
      
        @Override
        public void run() {
            while (true){
                boolean flg=sale();
                if(!flg){
                    break;
                }
            }

        }

        public synchronized boolean sale(){
            if (i > 0) {
                System.out.println("正在出票。。。");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                i--;
                System.out.println(Thread.currentThread().getName()+"当前剩余票数：" + i);
                return true;
            } else {
                return false;
            }
        }
    }

在方法里加上synchronized关键字即可

3、显式锁Lock

上代码：


        private int i=10;
        Lock l=new ReentrantLock();
        @Override
        public void run() {
            while (true){
//                boolean flg=sale();
//                if(!flg){
//                    break;
//                }
                l.lock();//锁上
                if (i > 0) {
                    System.out.println("正在出票。。。");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    i--;
                    System.out.println(Thread.currentThread().getName()+"当前剩余票数：" + i);

                }else{
                    break;
                }
                l.unlock();//解锁
            }

        }

使用Lock对象 直接调用lock方法锁住在执行完要锁的代码后unlock解锁，更加体现了面向对象的特点。

公平锁与不公平锁

公平锁：所有线程都排队执行
不公平锁：所有线程都去争抢执行

上面使用的同步代码块和同步方法都是不公平锁，但是Lock显式锁可以是公平锁也可以是不公平锁。
在初始化Lock对象时构造方法传入true参数，即可变成公平锁：

Lock l=new ReentrantLock(true);

线程死锁

概念引入：
有两个有试衣间，客人A去A试衣间，客人B去B试衣间。但是A觉得A试衣间不好用，想换到B试衣间，B觉得B试衣间不好用，想换到A试衣间。但是A和B都把自己的门锁住了，A在等B开锁，B在等A开锁。这时候怎么办呢？

场景：警察和罪犯对峙，警察要罪犯放了人质就放过他，罪犯要警察放了我就放了人质。双方尬住。。。

上代码：

package com.thread.demo;

//线程死锁的Demo
public class Demo {
    public static void main(String[] args) {
        Culprit c=new Culprit();
        Police p=new Police();
        new MyThread(c,p).start();
        c.say(p);
    }

    static class MyThread extends Thread{
        private Culprit c;//犯罪
        private Police p;//警察
        public MyThread(Culprit c,Police p){
            this.c=c;
            this.p=p;
        }

        @Override
        public void run() {
            p.say(c);
        }
    }

    static class Culprit{
        public synchronized void say(Police p){
            System.out.println("罪犯：你放了我，我放人质");
            p.fun();
        }

        public synchronized void fun(){
            System.out.println("罪犯被放走了，罪犯也放了人质");
        }
    }

    static class  Police{
        public synchronized void say(Culprit c){
            System.out.println("警察：你放了人质，我放过你");
            c.fun();
        }

        public synchronized void fun(){
            System.out.println("警察救了人质，但是罪犯跑了");
        }
    }
}

输出结果：
罪犯：你放了我，我放人质
警察：你放了人质，我放过你

这时候就尬住了。。。

解决方法：

在使用锁的方法里，不要调用别的使用锁的方法。

线程的六种状态

new–创建
Runnable–运行
Blocked–排队
Waiting–等待睡眠
TimeWaiting–指定时间休眠
Trminated–结束

带返回值的线程Callable

Callable在获取返回值时，只有Callable里的代码执行完，主线程才会继续执行…

public class Demo3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> c=new MyCallable();
        FutureTask<Integer> task=new FutureTask<>(c);
        new Thread(task).start();
        int result=task.get();
        System.out.println("返回值："+result);//在这里会等待执行完成才会继续执行下面的代码
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
    }

    static class MyCallable implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
                Thread.sleep(100);
            }
            return 100;
        }
    }
}

线程池

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间，线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量时间和资源。

1、缓存线程池

线程池里有多个线程，会优先使用最前面的线程执行任务，如果后面的线程长时间不执行任务会自动释放。

//缓存线程池
public class Demo4 {
    public static void main(String[] args) {
        
        ExecutorService service= Executors.newCachedThreadPool();
        //向线程池中加入新的任务
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
    }
}
2、定长线程池

由于会指定线程池的容量，如果使用的线程超过了这个容量，那么超出的线程会等待容器里的线程运行完。

具体使用方法和缓存线程池差不多，就是要指定容量大小。

ExecutorService service= Executors.newCachedThreadPool(2);//指定容量为2的线程池
3、单线程线程池

顾名思义，线程池里只有一个线程，所有任务都由同一个线程执行。

//单线程线程池
public class Demo5 {
    public static void main(String[] args) {
        ExecutorService service= Executors.newSingleThreadExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
    }
}

执行完发现都是由一个线程执行的。

pool-1-thread-1
pool-1-thread-1
pool-1-thread-1

4、周期定长线程池

直接上代码看注释吧


public class Demo6 {
    public static void main(String[] args) {
        ScheduledExecutorService service= Executors.newScheduledThreadPool(2);

        /**
         * 1.定时执行一次任务
         * 参数1：要执行的任务
         * 参数2：时长数字
         * 参数3：时长数字的时间单位，TimeUnit的常量指定
         */

        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("我是5秒后执行的任务");
            }
        },5, TimeUnit.SECONDS);


        /**
         * 2.周期执行任务
         * 参数1：要执行的任务
         * 参数2：延迟时长数字（第一次执行在什么时间后）
         * 参数3：周期时长数字（每隔多久执行一次）
         * 参数4：时长数字的单位
         */

        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("我是启动程序3秒后每隔1秒运行的任务");
            }
        },3,1,TimeUnit.SECONDS);
    }
}
mx_S
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代码随想录知识星球精华（第四版）最强八股文-Java篇
03-19
6. **多线程**：Java提供强大的多线程支持，包括线程的创建、同步、互斥和通信。熟悉线程的生命周期、并发模式以及线程安全问题的解决策略。 7. **反射机制**：Java反射允许在运行时检查类、接口、字段和方法的信息...
植物大战僵尸（java源代码）
07-01
《植物大战僵尸》是一款深受玩家喜爱的塔防游戏，其Java源代码对于初学者来说，是一份极好的学习资源。这个项目不仅展示了游戏的基本逻辑，还涵盖了Java编程的多个核心概念，包括对象、类、继承、多态以及图形用户...
JAVA多线程实现-实现Callable接口
山禾园地
03-19 888
1. 实现Callable接口public class ImplementsCallable implements Callable&lt;Integer&gt;2. 重写接口call()方法，即线程执行内容。    @Override     public Integer call() throws Exception { Thread.currentThread().setName("Thr...
api windows 线程加锁_从 0 到 1 实现一个线程池（二）实现篇
weixin_29067143的博客
12-16 133
一、前言前面的帖子《从 0 到 1 实现一个线程池(一)基础原理篇》，已经介绍过进程、线程、线程池等基本原理和相关源码，算是对线程池主流程的一个总体介绍，让我们基本理解线程池的原理和总体框架，也是自己对这块知识点的复习和记忆强化。为了加深理解，本篇就要动手从 0 到 1 实现一个简易版线程池，简易不代表功能缺失，核心流程和功能要一应俱全。建议先看到本篇的朋友或者对线程池不熟悉的朋友，先看...
创建线程的方式：3.实现Callable接口
我有满天星辰的博客
05-09 366
实现Callable接口 实现Callable接口，需要返回值类型：implements Callable 重写call方法，需要抛出异常 ：public Boolean call() throws Exception {} 创建目标对象 ：CallableTest callableTest = new CallableTest(); 创建执行服务：ExecutorService service = Executors.newFixedThreadPool(1); 提交执行：Future
ue多线程简单概述
llsansun的博客
03-26 994
在任务图中，每个任务都是由一个函数表示，可以在一个线程上执行。这个调度过程是自动完成的，无需手动干预。此外，如果线程需要访问UE的游戏对象和函数，则需要在创建线程时将主线程上下文传递给它。多线程是一种非常复杂的概念，需要对系统的底层结构和算法有深入的了解。在游戏开发中，多线程可以极大地提高游戏的性能，但是如果不小心处理，也可能导致游戏出现各种问题。FRunnable是UE的一个轻量级线程抽象，提供了简单的线程管理和同步方法。总之，UE的多线程模型提供了一种灵活且高效的方法来处理复杂的游戏逻辑。
Unreal5(虚幻五) 使用FRunnable做多线程
qq_42915442的博客
09-27 563
当点击按钮时，创建一个LsqAsyncStudyActor，并且绑定到OnAsyncSuccess委托事件，然后调用DoAsync函数。在DoAsync里面，先new一个线程对象LsqAsyncStudyThread1，这个线程对象是我自定义的，实现了FRunnable接口的。在操作完了，我还BroadCast了Actor的完成事件 MyActor->OnAsyncSuccess.Broadcast();使用UE的委托与事件的方式，通知调用者异步任务已经完成，可以过来取结果了。//在线程结束时销毁对象。
史上最强NDK入门项目实战完整版.zip
06-05
NDK（Native Development Kit）是Google为Android平台提供的一个工具集，它允许开发者使用C/C++等原生代码来编写部分应用，以提高性能、优化特定硬件功能或利用多线程优势。 在Android开发中，NDK主要应用于以下几...
基于Android的史上最强NDK入门项目实战.zip
11-12
你将学习如何使用智能指针、内存池等技术来避免这些问题，同时了解如何利用多线程、异步操作提高程序运行效率。 七、实际案例分析 在项目实战中，可能会涉及各种实际场景，例如游戏中的物理引擎、图像处理算法、音...
java语言如何学习.pdf
08-23
多线程机理是Java语言中非常重要的概念，学习者应该了解多线程机理的使用方法和优点，以便更好地编写Java程序。但是，需要注意的是，在很多应用中根本就不需要编写多线程程序。 六、了解网络编程 Java语言号称是...
【Java多线程】创建多线程方式三：实现Callable接口
qq_64976935的博客
02-06 858
3.FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。1. 可以对具体Runnable、Callable任务的执行结果进行取消、查询是 否完成、获取结果等。2.FutrueTask是Futrue接口的唯一的实现类。实现Callable接口是JDK5.0新增线程创建方式。4.需要借助FutureTask类，比如获取返回结果。1.相比run()方法，可以有返回值。3. 支持泛型的返回值。
Future和Callable的使用
小石潭记丶
12-19 609
介绍 方法get()结合ExecutorService中的submit(Callable<T>)的使用 方法submit(Callable<T>)可以执行参数为Callable的任务。 方法get()用于获取返回值。 package cn.java.Concurrency; import java.util.concurrent.Callable; /** * @author 小石潭记 * @date 2021/12/19 10...
Java学习39-Java 多线程安全：Callable接口
最新发布
weixin_42892630的博客
04-02 221
Callable接口能return数值回来，但是不能直接给Thread实例，需要引入中间的FutureTask实例.执行调用过程类似这样。补充，如果想要调出call方法那个返回值，用FutureTask的object调用get方法，即就是。Callable()使用了泛型参数，可以指明具体的call()的返回值类型，更灵活。如果在主线程中需要或许分线程call()的返回值，则此时的主线程是阻塞状态的。call()可以使用throws的方式处理异常，更灵活。call()可以有返回值，更灵活。
callable的使用方法详解
qq_49529172的博客
04-16 8576
1.callable的使用方法 2.为何能带有返回值？源码解析
java中callable的使用
mameng1988的博客
03-18 4039
我们知道使用callable可以获得线程中的返回值，下面我们简单介绍callable的使用。 1 创建两个callable的实现类 1.1 BumCallable public class BumCallable implements Callable { @Override public Object call() throws Exception { try {...
ue4的多线程如何实现
tianxiaojie_blog的博客
11-20 1万+
ue4的多线程如何实现讲道理实例创建c++工程新建一个FunctionLibrary在functionlibrary里编写三个函数,并且在cpp里面加以实现再创建一个空类对该项目在vs 上进行生成创建测试用例结论 讲道理 一般要使用多线程技术的，就是该功能点费时，并且降低效率，阻碍体验。 就ue4来说，多线程一般用于后台的计算，信号的发送，检测等。 比如，通过开启一个线程进行心跳检测，确认码的发送...
UE4多线程
WLSTLA
11-19 4261
UE4 多线程 ​ UE4虽然沿用了C++11的标准，但多线程并没有使用std::thread,而是自己封装了Runnable、AsyncTask以及TaskGraph这三个可以供我们使用的线程。他们的本质相同但用法不同，使用Runnable可以自己创建复写线程函数的接口，AsyncTask是基于Runnable的一层封装，使用会更加方便。而TaskGraph则是基于任务的多线程(Task-Based)，可以有效控制任务的顺序性。接下来将简单介绍这三种线程的使用。 1. Runnable ​ Runnabl
多线程与并发 - 如何实现处理线程的返回值
热门推荐
简单记录一下。
03-16 20万+
如何给run()方法传参 构造函数传参 成员变量传参 回调函数传参 如何实现处理线程的返回值 主线程等待法（即让主线程循环等待，直到目标子线程返回值为止）
JAVA多线程执行结果汇总，多线程执行，将结果汇总后返回给主线程
尽量致力于发表微服务、中间件和算法等原创作品。
06-01 9313
/** * 多线程执行结果汇总工具 * * @author 张帅 * @date 2021年05月20日 11时28分02秒 * @version V1.0 * * @param <T> */ @Slf4j public class MultiFutureThread<T> { // 总线程数量 private int threadSize; // 单次执行多少次线程 private int singleSize; ...
Java多线程.pdf
09-28
"这份资料详细介绍了Java多线程编程的相关知识，包括线程的创建、线程安全和锁机制，以及线程池的使用。" 在Java编程中，多线程技术是核心概念之一，它允许程序同时执行多个任务，提高了程序的效率和响应性。Java多...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值