JAVA中的多线程操作详细剖析

最新推荐文章于 2024-08-17 00:13:36 发布
最新推荐文章于 2024-08-17 00:13:36 发布
阅读量840 收藏
点赞数
文章标签： java 开发语言 后端 程序人生 架构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/uuuyy_/article/details/122111947
版权
本文详细介绍了JAVA中多线程的创建方式，包括继承Thread、实现Runnable和Callable接口以及使用线程池。还探讨了线程安全问题，通过同步代码块、同步方法和ReentrantLock解决并发控制。最后总结了两种线程创建方式的对比及同步方法的应用。
摘要由CSDN通过智能技术生成

一，前提

一说到多线程，就不得不提进程，线程，程序的概念：

先说进程，一说到进程，就不能不说一下程序，程序是指令和数据的有序集合，其本身没有任何的含义，是一个静态的概念。而进程是执行程序的一次执行过程，它是个一个动态的概念，是系统资源分配的单元。

通常在一个进程中可以包含若干个线程，当然，一个进程中至少是有一个线程，不然没有存在的意义，线程是CPU调度和执行的单位。

Note: 很多多线程都是模拟出来的，真正的多线程是指多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所有就由同时执行的错觉。

而对于多进程类似于下图的操作：

总结一下：

  1. 线程就是一个独立的执行单位。
  2. 在程序运行时，就算你没有自己创建进程进行编程，后台也会有多个线程在运行，如main，gc线程。
  3. main()主线程，作为程序的入口，用于执行整个程序。
  4. 在一个进程中，如果开辟了多个线程，线程的运行是由调度器安排调度的，调度器是和操作系统紧密相关，先后顺序是不能进行干预的。
  5. 对同一份资源操作时，会存在资源争夺的问题，需要加入并发控制。
  6. 线程会带来额外的开销，如cpu调度时间，并发控制开销。
  7. 每个线程都在自己的工作内存中工作，内存控制不当会造成数据不一致。

需要掌握的几部分

  1. 创建线程的几种方式
  2. 线程的安全问题与几种机制
  3. 线程之间的通信问题解决方案

二，线程的创建

多线程的创建方式，比较常规的说法是两种方式：1. 继承Thread类 2. 实现Runnable接口。

但是严格来说，有四种：3. 实现Callable接口。4. 线程池

2.1 继承Thread类

步骤：

  1. 创建一个 继承于Thread的子类
  2. 重写Thread类的 run方法 。（将此线程执行的操作声明在run方法中）
  3. 创建Thread类的子类对象
  4. 通过此对象调用**start()**方法

实例代码：

public static void main(String[] args) throws InterruptedException {
 
//        3. 创建Thread类的子类对象
        MyThread t1 = new MyThread();
//        4. 通过此对象调用start()方法 : 1 .导致此线程开始执行 2.Java虚拟机调用此线程的run方法。
        t1.start();
//        t1.run (只是做了一个创建对象，然后调用对象中的方法操作，等调用的方法执行结束之后，才会执行下面的代码，
//        不会启动一个新的线程)
//        问题1： 我们不能通过直接调用run方法的方式直接调用
//        t1.start();
//        问题2： 在启动一个线程，遍历100以内的偶数。
//        再启动一个线程，不可以让已经start()的线程在去调用start()执行，否则会报 IllegalThreadStateException
//        需要重新创建一个对象来调用start()方法
        MyThread t2 = new MyThread();
        t2.start();

//        如下的操作仍然是在main线程中执行的
        for (int i = 0; i < 100; i++) {
 
            if(i % 2 == 0){
 
                System.out.println(Thread.currentThread().getName() + " ======main======== " + i);
            }
        }
    }
}
// 1. 创建一个继承于Thread的子类。
class MyThread extends Thread{
 
// 2. 重写Thread类的run方法。
    @Override
    public void run() {
 
        for (int i = 0; i < 100; i++) {
 
            if(i % 2 == 0){
 
                System.out.println(Thread.currentThread().getName()+ " ========= ======" + i);
            }
        }
    }

2.2 实现Runnable接口

步骤：

  1. 创建一个是实现了Runnable接口的一个类。
  2. 实现类去实现Runnable接口中的抽象方法：run()
  3. 创建实现类的对象
  4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象。
  5. 通过Thread类的对象调用start()方法

代码：

/ 1. 创建一个实现了Runnable接口的一个类。
class MThread implements Runnable {
 
    
    // 2. 实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
 
        for (int i = 0; i < 100; i++) {
 
            if (i % 2 == 0) {
 
                System.out.println(Thread.currentThread().getName() + " === " + i);
            }
        }
    }
}
public class A_03ThreadTest {
 
    public static void main(String[] args) {
 
//        3. 创建实现类的对象
        MThread mThread = new MThread();
//        4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象。
        Thread t1 = new Thread(mThread);
//        5. 通过Thread类的对象调用start(); 作用： 1. 启动线程
//                                             2.调用当前线程的run()方法 --- > 调用了Runnable类型中target的run()方法
        t1.start();

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

除了以上有通过实现Runnable接口和继承Thread类的方式来创建线程之外，还有两种方法是JDK5新增的两种方法来创建线程。

2.3 实现callable接口

如何理解callable接口的方式创建线程的方式比实现Runnable接口创建线程的方式要强大？

  1. call() 方法是可以有返回值的。
  2. call() 可以抛出异常，被外面的操作捕获。
  3. callable() 是支持泛型的。

代码实例：

// 1.创建一个实现callable的实现类
class NumThread implements Callable{
 
//  2. 实现call方法，将此线程需要执行的操作声明在call方法中
    @Override
    public Object call() throws Exception {
 
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
 
            if (i % 2 == 0) {
 
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}
public class ThreadNew {
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
 
//        3. 创建callable接口实现类的对象
        NumThread t = new NumThread();
//        4. 将此callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(t);
//        5. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start方法
        new Thread(futureTask).start();
//        6. 获取callable中call方法中的返回值
//        get 方法的返回值，就为futuretask构造器参数callable实现类重写的call方法的返回值
        int sum = (Integer)futureTask.get();
        System.out.println("总和为" + sum);

    }

}

2.4 线程池

好处：

  1. 提高相应速度（减少了创建新线程的时间）
  2. 减低资源消耗（重复利用线程池中线程，不需要每次创建）
  3. 便于线程管理

代码示例：

class NumberThread implements Runnable{
 
    @Override
    public void run() {
 
        for (int i = 0; i <= 100; i++) {
 
            if (i % 2 == 0) {
 
                System.out.println(Thread.currentThread().getName() + " ::" + i);
            }
        }
    }
}
class NumberThread1 implements Runnable{
 
    @Override
    public void run() {
 
        for (int i = 0; i <= 100; i++) {
 
            if (i % 2 == 0) {
 
                System.out.println(Thread.currentThread().getName() + " ::" + i);
            }
        }
    }
}
public class ThreadPool {
 
    public static void main(String[] args) {
 
//        1.提供指定数量的线程池
        ThreadPoolExecutor service = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
//        设置线程池属性
        service.setCorePoolSize(100);
//        service.setKeepAliveTime(1000);
//          2. 执行执行线程的操作，需要提供Runnable接口或者是Callable接口实现类的对象
        service.execute(new NumberThread()); // 适合使用runnable
        service.execute(new NumberThread1()); // 适合使用runnable
//        service.submit(); // 适合使用与callable
//        3.关闭连接池
        service.shutdown();
    }
}

三，线程安全问题

在进行买票问题的分析上，发现了有可能票数会出现不一致的情况，所以需要一定的安全机制来避免这种情况。

出现原因：某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。

如何解决：

当一个线程在操作ticket的时候， 其他线程不能参与进来，直到当前线程操作完毕之后，其他线程才可以操作ticket，即是是当前线程出现了堵塞，情况也不能改变。

在java中主要通过同步机制来解决线程的安全问题：

实现同步机制有以下几种方式：

3.1 同步代码块

【语法】
synchronized(同步监视器){
 
    // 需要被同步的代码
}

说明分析：

  1. 操作共享数据的代码，即为需要被同步的代码。（不能包含多了，有可能会出错），也不能包含少。
  2. 共享数据：多个线程共同操作的变量。
  3. 同步监视器：俗称“锁”。任何一个对象，都可以充当锁。
    要求：多个线程必须公用公用一把锁。(调用的时候，传入的是同一个对象)。`

补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器

一定是只是创建了一个Runnable接口的对象传入到Thread中的构造方法中，才能保证是同一个对象

在实现Runnable接口的实现类中使用同步代码块解决安全机制：

class Window1 implements Runnable {
 
    private int ticket = 100;
    Object lock = new Object();
    @Override
    public void run() {
 
        while (true) {
 
//            由于只是new了一个对象，所以，可以使用this关键字来进行代替 此时的this代表的就是window1的对象
            synchronized(lock){
 
                if (ticket > 0) {
 
//                    将程序进行缓慢执行0.1秒
                    try {
 
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
 
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "：买票， 票号是" + ticket);
                    ticket--;
                } else {
 
                    break;
                }
            }
        }
    }
}
// 【实现的方式解决线程安全问题】
public class C_01WindowTest1 {
 
    public static void main(String[] args) {
 
//        由于只是new了一个window的对象，所以Window1类中多个线程都是共享一个lock对象
        Window1 w = new Window1();
//        在构造方法中传入实现了runnable接口的类
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
//      命名操作
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
//      start()开启线程
        t1.start();
        t2.start();
        t3.start();
    }
}

需要注意的是：由于实现了Runnable的这个类只是new了一个对象，所以成员变量 Object lock = new Object(); 的对象所有的线程属于是同一个，所以可以达到同步的目的。

如果是 继承Thread的方式实现多线程的方式，需要注意的是需要把锁的对象声明成static，才能使所有的线程都是共享一个lock的变量 。

class Window2 extends Thread {
 
//    出现线程安全问题
    private static int ticket = 100;
//    private Object lock = new Object(); 由于同步代码块中的锁不是同一个，所以出现了没有解决同步安全的现象，只要把所有的锁对象换成
//    同一个，那么就可以解决同步的问题，解决方案是，让他们共享同一个对象
    private static Object lock = new Object(); // 解决了线程安全的问题
    @Override
    public void run() {
 
            while (true) {
 
//                不能使用this关键字作为同步锁 this代表着 t1 , t2, t3三个对象
//                synchronized(Window2.class){ 但是可以他们是公用一个类对象，所以，通用一个类对象来进行。类只会加载一次。
                synchronized(lock){
 
                    if (ticket > 0) {
 
                        try {
 
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
 
                            e.printStackTrace();
                        }
                        System.out.println(getName() + ":买票， 票号是： " + ticket);
                        ticket--;
                    }else{
 
                        break;
                    }
                }
            }
    }
}

public class C_02WindowTest2 {
 
    public static void main(String[] args) {
 
//        创建三个对象
        Window2 w1 = new Window2();
        Window2 w2 = new Window2();
        Window2 w3 = new Window2();
//        命名
        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");
//        启动线程
        w1.start();
        w2.start();
        w3.start();
    }
}

需要注意的是，锁一定要是同一个。

3.2 同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨考虑将此方法声明为同步的。

【使用实现Runnable接口的方式解决线程安全问题】

public class ThreadTest04 {
 
    public static void main(String[] args) {
 
        Window target = new Window();
//        创建线程Thread
        Thread t1 = new Thread(target);
        Thread t2 = new Thread(target);
        Thread t3 = new Thread(target);
        t1.setName("window - one");
        t2.setName("window - two");
        t3.setName("window - three");
        t1.start();
        t2.start();
        t3.start();
    }
}
class Window implements Runnable{
 
//    总的票数 所有的实例对象只有一个
    private static int ticket = 100;
    @Override
    public void run() {
 
            while (true) {
 
                if (show()) break;
            }
    }
  // 使用关键字synchronized来将show方法作为一个同步方法来解决同步问题
    private synchronized boolean show() {
 
        if (ticket > 0) {
 
            System.out.println(Thread.currentThread().getName() + "买票，买票的票号是" + ticket);
            ticket --;
        } else{
 
            return true;
        }
        return false;
    }
}

原理分析： 由于此时的this，在Runnable只是创建了一个对象，所以，this对象可以为多个线程公用同一把锁。同步方法默认是使用当前对象的this作为同步的锁。

如果是使用继承Thread类的方法解决线程安全问题的写法又是会有些不同。

【使用继承Thread类方法的方式解决线程安全问题】

public class ThreadTest05 {
 
    public static void main(String[] args) {
 
//        创建线程
        Window2 t1 = new Window2();
        Window2 t2 = new Window2();
        Window2 t3 = new Window2();
//        设置名字
        t1.setName("window-one");
        t2.setName("window-two");
        t3.setName("window-three");
//        启动多个线程
        t1.start();
        t2.start();
        t3.start();
    }
}
class Window2 extends Thread{
 
    private static int ticket = 100;
    private static Object lock = new Object();
    @Override
    public void run() {
 
            while (true) {
 
                if (show()) break;
            }
    }
// 由于此时的调用当前同步方法的对象不是同一个，所以this指代的也不是同一个，所以进行同步方法的时候，需要加上一个static,保证锁是同一把锁
    private static synchronized boolean show() {
 
        if (ticket > 0) {
 
            System.out.println(Thread.currentThread().getName() + "买票，买票的票号是" + ticket);
            ticket --;
        } else{
 
            return true;
        }
        return false;
    }
}

注意：此时需要注意的是，在同步方法中，由于同步方法默认使用的是调用当前方法的this作为多个线程的同步监视器，所以，如果不声明成静态的方法，则this指示的是不同的对象，所以，需要声明程静态方法。

3.3 加锁实现同步

3.3.1ReentrantLock 锁

一种新的实现线程之间同步的方式：

  1. 创建一个ReentrantLock锁
ReentrantLock lock = new ReentrantLock(true);

2.在需要同步的关键地方加锁

lock.lock();

3.线程同步代码结束之后需要进行解锁操作。

lock.unlock();

详细请看：

synchronized和锁(ReentrantLock) 区别_小风筝-CSDN博客

四. 线程通信问题

设计到三个方法

注意事项：

代码示例：

class Number implements Runnable{
 
    private int number = 1;
    private Object obj = new Object();
    @Override
    public void run() {
 
        while (true) {
 
//            利用同步代码块
            synchronized (obj) {
 

//                 notifyall() 是唤醒所有的堵塞线程   notify按照优先级的高低，释放优先级最高的线程
                obj.notify();

                if (number <= 100) {
 
                    try {
 
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
 
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;
//                  使用调用如下wait()方法的线程进入到堵塞状态，wait是会释放锁
                    try {
 
                        obj.wait();
                    } catch (InterruptedException e) {
 
                        e.printStackTrace();
                    }

                } else {
 
                    break;
                }
            }
        }
    }
}
public class CommunicationTest {
 
    public static void main(String[] args) {
 
        Number number = new Number();
//      创建两个Thread对象
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);
//        命名
        t1.setName("线程1");
        t2.setName("线程2");
//        启动
        t1.start();
        t2.start();
    }
}

五，总结与概括

5.1 线程中两种创建方式（继承Thread和实现Runnable接口）的对比

无论是哪种方法，切入点都是Thread类，区别是：

继承 Thread类的顺序是： Thread.start() -> Thread.run()
实现Runnable 接口的顺序是： Thread.start() -> Thread.run() -> Runnable .run()

Runnable接口：天然的实现数据共享，如果继承，则需要设置为静态的。

开发中：优先选择Runnable接口的方式。

原因：

  1. 实现的方式没有类的单继承的局限性。

    ​2. 实现的方式更适合来处理多个线程共享数据的情况。

联系: class Thread implements Runnable

不管是继承还是实现的方式，都需要重写Runnable接口，都需要重写run()方法，将线程需要执行的逻辑声明在run()中。

5.2 同步方法总结

关于同步方法的总结：

​ 1.同步方法仍然设计到同步监视器，只是不需要我们显示的进行声明。

​ 2.非静态的同步方法，同步监视器是：this。

​ 3.静态的同步方法，同步监视器是当前类本身

同步的方式，解决了线程安全问题 — 好处

操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。

如果看完的小伙伴有兴趣了解更多的话，欢迎添加vx小助手：SOSOXWV  免费领取资料哦！

Java小果
关注
java的多线程使用方法
01-24
java多线程的使用方法如何使用，怎么使用，使用过程中有什么要注意的
Java中join线程操作实例分析
08-25
Join线程操作是Java多线程编程中的一种重要机制，它允许一个线程等待另外一个线程完成。通过join()方法，可以实现线程之间的同步操作。 在Java中，线程可以通过join()方法来等待其他线程的完成。join()方法通常由...
Java 多线程操作
wuyouke的专栏
09-10 319
在介绍多线程之前，先介绍并发和并行的区别： 并发：是指在某一段时间内发生多个事件； 并行：是指在同一时刻发生多个事件； 在操作系统中，有多个CPU，可以并发进行多程序的并发执行，而单CPU，只能进行CPU资源的调度，并行执行程序； 进程和线程的区别： 进程：拥有自己独立的内存空间； 线程：最小的CPU调度单位 多线程实现方式： 1）继承于java.lang.Thread 定义类，...
Java中的线程创建和同步快速入门（保姆级教程）
最新发布
流水悠然，任山川引路。
08-17 1137
当 Java 程序启动时，它会创建一个主线程（main线程），并可能会启动其他子线程。程序会等待所有用户线程完成后才会终止。守护线程：与用户线程不同，守护线程是用来在后台执行支持性任务的，当所有用户线程结束时，守护线程会自动终止，不管它是否完成了自己的任务。
详细剖析：JAVA中的多线程操作
wdj_yyds的博客
12-24 866
previous: 目前在复习基础中… 文章目录 一，前提 一说到多线程，就不得不提进程，线程，程序的概念： 先说进程，一说到进程，就不能不说一下程序，程序是指令和数据的有序集合，其本身没有任何的含义，是一个静态的概念。而进程是执行程序的一次执行过程，它是个一个动态的概念，是系统资源分配的单元。 通常在一个进程中可以包含若干个线程，当然，一个进程中至少是有一个线程，不然没有存在的意义，线程是CPU调度和执行的单位。 Note: 很多多线程都是模拟出来的，真正的多线程是指多个cpu，即多核，如.
Java多线程操作
qq_41291067的博客
03-18 251
同步与互斥 在 Java 中实现多线程有两种手段，一种是继承 Thread 类，另一种就是实现 Runnable 接口。下面我们就分别来介绍这两种方式的使用。 方式一：继承Thread类 public static void main(String[] args) { Mythread my1 = new Mythread("线程A"); Mythread my2 = new Mythread("线程B"); my1.start(); my2.start(); } publi
Java多线程操作<二>
FLY_THINK2012的博客
07-24 93
同步段代码演示(关键代码段),wait(),notify()方法只能在snychronized标示的代码段和方法中使用,并且需要异常处理. /*** */ /*** @author Administrator**/public class TicketSystem { /** * @param args */public static void main(Stri...
详解Java多线程处理List数据
08-26
Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List数据的知识点。 一、什么是...
Java实现多线程轮流打印1-100的数字操作
09-07
本文将详细讲解如何使用Java实现多线程轮流打印1-100的数字，以及在此过程中遇到的并发问题及其解决方案。 首先，我们要理解基本的Java线程创建和运行方式。在示例代码中，通过`Thread`类和`Runnable`接口创建了多...
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
java使用多线程找出最大随机数
08-18
Java多线程编程是一种复杂的编程技术，需要充分理解Java的多线程机制和线程安全问题。使用多线程需要小心编写代码，避免线程安全问题和死锁问题。 在这个示例中，使用了Thread类来创建线程，然后使用start方法来...
java 多线程操作
chaoyue1397的博客
02-15 640
大家过年好.新年一帆风顺! 工作中的某个需要多线程操作的功能,记录一下(简略代码)利用线程池 ExecutorService 产生一个有固定线程数的线程池其中如果任务多余线程数量进行队列分块进行解决. public class ProcessListUtil{ public Map manyProcessForCloud(String[] task,XmlRpcClientConfigImp
java 线程 操作_java多线程操作
weixin_42425824的博客
02-20 135
进程是程序的一次动态的执行过程,它经历了从代码加载、执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到最终消亡的过程。多线程是实现并发机制的一种有效的手段。进程和线程一样，都是实现并发的一个基本单位。如果现在同时运行多个任务，则所有的系统资源将是共享的，补所有线程所公用，但是程序处理需要CPU，传统的单核CPU来说 ，在同一个时间段上会有多个程序执行，但是在同一个时间点上只能存在一个程序运...
Java的多线程操作 一
wszhm123的博客
03-01 197
在开发的有时候，我们都会遇到系统需要处理非常多的执行时间很短的请求，如果每一个请求都开启一个新线程的话，系统就要不断的进行线程的创建和销毁，有时花在创建和销毁线程上的时间会比线程真正执行的时间还长。而且当线程数量太多时，系统不一定能受得了。使用线程池主要为了解决一下几个问题：通过重用线程池中的线程，来减少每个线程创建和销毁的性能开销。对线程进行一些维护和管理，比如定时开始，周期执行，并发数控制等等...
Java多线程操作<一>
FLY_THINK2012的博客
07-24 86
Example <一>: /*** */ /*** @author Administrator**/public class MultiThread { /** * @param args */public static void main(String[] args) {// TODO Auto-generated method stubMy...
JAVA进阶学习笔记(1)：多线程
LeavingBook的博客
09-01 741
1 基本概念 1.1 程序 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 1.2 进程 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态 的过程：有它自身的产生、存在和消亡的过程。——生命周期 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 。 1.3 线程 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。 1.若一个进程同一时间并行执行多个线程，就是支持多线程的 2.线程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值