Synchronized修饰方法和代码块在底层的一些区别

最新推荐文章于 2022-07-11 02:00:40 发布
最新推荐文章于 2022-07-11 02:00:40 发布
阅读量871 收藏
点赞数
分类专栏： java进击之路 文章标签： java jvm 多线程 高并发 synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/richard1230/article/details/106966652
版权

文章目录

修饰代码块

上例子:

public class SyncCodeBlock {
    public int i;

    public void syncTask(){
        //同步代码库
        synchronized (this){
            i++;
        }
    }
}

使用javac编译,使用javap查看字节码:


$javac SyncCodeBlock.java
$javap -v -c -s -l SyncCodeBlock.class
Classfile /Users/mac/IdeaProjects/multiThread/src/main/java/ThreadBasic/Synchronized/SyncCodeBlock.class
  Last modified 2020-6-26; size 427 bytes
  MD5 checksum 46c58b50c71e6579e6e3d8b903ac2680
  Compiled from "SyncCodeBlock.java"
public class ThreadBasic.Synchronized.SyncCodeBlock
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #4.#18         // java/lang/Object."<init>":()V
   #2 = Fieldref           #3.#19         // ThreadBasic/Synchronized/SyncCodeBlock.i:I
   #3 = Class              #20            // ThreadBasic/Synchronized/SyncCodeBlock
   #4 = Class              #21            // java/lang/Object
   #5 = Utf8               i
   #6 = Utf8               I
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               syncTask
  #12 = Utf8               StackMapTable
  #13 = Class              #20            // ThreadBasic/Synchronized/SyncCodeBlock
  #14 = Class              #21            // java/lang/Object
  #15 = Class              #22            // java/lang/Throwable
  #16 = Utf8               SourceFile
  #17 = Utf8               SyncCodeBlock.java
  #18 = NameAndType        #7:#8          // "<init>":()V
  #19 = NameAndType        #5:#6          // i:I
  #20 = Utf8               ThreadBasic/Synchronized/SyncCodeBlock
  #21 = Utf8               java/lang/Object
  #22 = Utf8               java/lang/Throwable
{
  public int i;
    descriptor: I
    flags: ACC_PUBLIC

  public ThreadBasic.Synchronized.SyncCodeBlock();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0

  public void syncTask();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=3, args_size=1
         0: aload_0
         1: dup
         2: astore_1
         3: monitorenter
         4: aload_0
         5: dup
         6: getfield      #2                  // Field i:I
         9: iconst_1
        10: iadd
        11: putfield      #2                  // Field i:I
        14: aload_1
        15: monitorexit
        16: goto          24
        19: astore_2
        20: aload_1
        21: monitorexit
        22: aload_2
        23: athrow
        24: return
      Exception table:
         from    to  target type
             4    16    19   any
            19    22    19   any
      LineNumberTable:
        line 9: 0
        line 10: 4
        line 11: 14
        line 12: 24
      StackMapTable: number_of_entries = 2
        frame_type = 255 /* full_frame */
          offset_delta = 19
          locals = [ class ThreadBasic/Synchronized/SyncCodeBlock, class java/lang/Object ]
          stack = [ class java/lang/Throwable ]
        frame_type = 250 /* chop */
          offset_delta = 4
}
SourceFile: "SyncCodeBlock.java"

JVM 是通过进入、退出对象监视器( Monitor )来实现对代码块的同步的。

修饰实例方法

public class SyncInstance implements  Runnable{
        static int i = 0;

        public synchronized void increase() {
            i++;
        }

        @Override
        public void run() {
            for (int j = 0; j < 5; j++) {
                increase();
            }
        }

        public static void main(String[] args) throws InterruptedException {
            //new新实例
            Thread t1 = new Thread(new SyncInstance());
            //new新实例
            t1.start();
            //join含义:当前线程A等待thread线程终止之后才能从thread.join()返回
            t1.join();
        }
}

查看其字节码:

$javac SyncInstance.java
$javap -v -c -s -l SyncInstance.class
Classfile /Users/mac/IdeaProjects/multiThread/src/main/java/ThreadBasic/Synchronized/SyncInstance.class
  Last modified 2020-6-26; size 769 bytes
  MD5 checksum 4bc0bc765b64da5799760cf7a04b01cc
  Compiled from "SyncInstance.java"
public class ThreadBasic.Synchronized.SyncInstance implements java.lang.Runnable
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #10.#28        // java/lang/Object."<init>":()V
   #2 = Fieldref           #5.#29         // ThreadBasic/Synchronized/SyncInstance.i:I
   #3 = Methodref          #5.#30         // ThreadBasic/Synchronized/SyncInstance.increase:()V
   #4 = Class              #31            // java/lang/Thread
   #5 = Class              #32            // ThreadBasic/Synchronized/SyncInstance
   #6 = Methodref          #5.#28         // ThreadBasic/Synchronized/SyncInstance."<init>":()V
   #7 = Methodref          #4.#33         // java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
   #8 = Methodref          #4.#34         // java/lang/Thread.start:()V
   #9 = Methodref          #4.#35         // java/lang/Thread.join:()V
  #10 = Class              #36            // java/lang/Object
  #11 = Class              #37            // java/lang/Runnable
  #12 = Utf8               i
  #13 = Utf8               I
  #14 = Utf8               <init>
  #15 = Utf8               ()V
  #16 = Utf8               Code
  #17 = Utf8               LineNumberTable
  #18 = Utf8               increase
  #19 = Utf8               run
  #20 = Utf8               StackMapTable
  #21 = Utf8               main
  #22 = Utf8               ([Ljava/lang/String;)V
  #23 = Utf8               Exceptions
  #24 = Class              #38            // java/lang/InterruptedException
  #25 = Utf8               <clinit>
  #26 = Utf8               SourceFile
  #27 = Utf8               SyncInstance.java
  #28 = NameAndType        #14:#15        // "<init>":()V
  #29 = NameAndType        #12:#13        // i:I
  #30 = NameAndType        #18:#15        // increase:()V
  #31 = Utf8               java/lang/Thread
  #32 = Utf8               ThreadBasic/Synchronized/SyncInstance
  #33 = NameAndType        #14:#39        // "<init>":(Ljava/lang/Runnable;)V
  #34 = NameAndType        #40:#15        // start:()V
  #35 = NameAndType        #41:#15        // join:()V
  #36 = Utf8               java/lang/Object
  #37 = Utf8               java/lang/Runnable
  #38 = Utf8               java/lang/InterruptedException
  #39 = Utf8               (Ljava/lang/Runnable;)V
  #40 = Utf8               start
  #41 = Utf8               join
{
  static int i;
    descriptor: I
    flags: ACC_STATIC

  public ThreadBasic.Synchronized.SyncInstance();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0

  public synchronized void increase();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_SYNCHRONIZED
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field i:I
         3: iconst_1
         4: iadd
         5: putstatic     #2                  // Field i:I
         8: return
      LineNumberTable:
        line 7: 0
        line 8: 8

  public void run();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=2, args_size=1
         0: iconst_0
         1: istore_1
         2: iload_1
         3: iconst_5
         4: if_icmpge     17
         7: aload_0
         8: invokevirtual #3                  // Method increase:()V
        11: iinc          1, 1
        14: goto          2
        17: return
      LineNumberTable:
        line 12: 0
        line 13: 7
        line 12: 11
        line 15: 17
      StackMapTable: number_of_entries = 2
        frame_type = 252 /* append */
          offset_delta = 2
          locals = [ int ]
        frame_type = 250 /* chop */
          offset_delta = 14

  public static void main(java.lang.String[]) throws java.lang.InterruptedException;
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=4, locals=2, args_size=1
         0: new           #4                  // class java/lang/Thread
         3: dup
         4: new           #5                  // class ThreadBasic/Synchronized/SyncInstance
         7: dup
         8: invokespecial #6                  // Method "<init>":()V
        11: invokespecial #7                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
        14: astore_1
        15: aload_1
        16: invokevirtual #8                  // Method java/lang/Thread.start:()V
        19: aload_1
        20: invokevirtual #9                  // Method java/lang/Thread.join:()V
        23: return
      LineNumberTable:
        line 19: 0
        line 21: 15
        line 23: 19
        line 24: 23
    Exceptions:
      throws java.lang.InterruptedException

  static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=1, locals=0, args_size=0
         0: iconst_0
         1: putstatic     #2                  // Field i:I
         4: return
      LineNumberTable:
        line 4: 0
}
SourceFile: "SyncInstance.java"

synchronized修饰的实例方法并没有monitorenter指令和monitorexit指令，取而代之的是ACC_SYNCHRONIZED标识，该标识指明了该方法是一个同步方法，JVM通过该ACC_SYNCHRONIZED访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用;

修饰静态方法

package ThreadBasic.Synchronized;

public class SynStatic implements Runnable {
    static int i = 0;

    public static synchronized void increase() {
        i++;
    }

    @Override
    public void run() {
        for (int j = 0; j < 5; j++) {
            increase();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //new新实例
        Thread t1 = new Thread(new SynStatic());
        //new新实例
        t1.start();
        //join含义:当前线程A等待thread线程终止之后才能从thread.join()返回
        t1.join();
    }
}

查看其字节码:

$javac SynStatic.java
$javap -c -v -s -l SynStatic.class
Classfile /Users/mac/IdeaProjects/multiThread/src/main/java/ThreadBasic/Synchronized/SynStatic.class
  Last modified 2020-6-26; size 762 bytes
  MD5 checksum f66c06958c4b1a7b9e84d47933cc6dda
  Compiled from "SynStatic.java"
public class ThreadBasic.Synchronized.SynStatic implements java.lang.Runnable
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #10.#28        // java/lang/Object."<init>":()V
   #2 = Fieldref           #5.#29         // ThreadBasic/Synchronized/SynStatic.i:I
   #3 = Methodref          #5.#30         // ThreadBasic/Synchronized/SynStatic.increase:()V
   #4 = Class              #31            // java/lang/Thread
   #5 = Class              #32            // ThreadBasic/Synchronized/SynStatic
   #6 = Methodref          #5.#28         // ThreadBasic/Synchronized/SynStatic."<init>":()V
   #7 = Methodref          #4.#33         // java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
   #8 = Methodref          #4.#34         // java/lang/Thread.start:()V
   #9 = Methodref          #4.#35         // java/lang/Thread.join:()V
  #10 = Class              #36            // java/lang/Object
  #11 = Class              #37            // java/lang/Runnable
  #12 = Utf8               i
  #13 = Utf8               I
  #14 = Utf8               <init>
  #15 = Utf8               ()V
  #16 = Utf8               Code
  #17 = Utf8               LineNumberTable
  #18 = Utf8               increase
  #19 = Utf8               run
  #20 = Utf8               StackMapTable
  #21 = Utf8               main
  #22 = Utf8               ([Ljava/lang/String;)V
  #23 = Utf8               Exceptions
  #24 = Class              #38            // java/lang/InterruptedException
  #25 = Utf8               <clinit>
  #26 = Utf8               SourceFile
  #27 = Utf8               SynStatic.java
  #28 = NameAndType        #14:#15        // "<init>":()V
  #29 = NameAndType        #12:#13        // i:I
  #30 = NameAndType        #18:#15        // increase:()V
  #31 = Utf8               java/lang/Thread
  #32 = Utf8               ThreadBasic/Synchronized/SynStatic
  #33 = NameAndType        #14:#39        // "<init>":(Ljava/lang/Runnable;)V
  #34 = NameAndType        #40:#15        // start:()V
  #35 = NameAndType        #41:#15        // join:()V
  #36 = Utf8               java/lang/Object
  #37 = Utf8               java/lang/Runnable
  #38 = Utf8               java/lang/InterruptedException
  #39 = Utf8               (Ljava/lang/Runnable;)V
  #40 = Utf8               start
  #41 = Utf8               join
{
  static int i;
    descriptor: I
    flags: ACC_STATIC

  public ThreadBasic.Synchronized.SynStatic();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0

  public static synchronized void increase();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
    Code:
      stack=2, locals=0, args_size=0
         0: getstatic     #2                  // Field i:I
         3: iconst_1
         4: iadd
         5: putstatic     #2                  // Field i:I
         8: return
      LineNumberTable:
        line 7: 0
        line 8: 8

  public void run();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=2, args_size=1
         0: iconst_0
         1: istore_1
         2: iload_1
         3: iconst_5
         4: if_icmpge     16
         7: invokestatic  #3                  // Method increase:()V
        10: iinc          1, 1
        13: goto          2
        16: return
      LineNumberTable:
        line 12: 0
        line 13: 7
        line 12: 10
        line 15: 16
      StackMapTable: number_of_entries = 2
        frame_type = 252 /* append */
          offset_delta = 2
          locals = [ int ]
        frame_type = 250 /* chop */
          offset_delta = 13

  public static void main(java.lang.String[]) throws java.lang.InterruptedException;
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=4, locals=2, args_size=1
         0: new           #4                  // class java/lang/Thread
         3: dup
         4: new           #5                  // class ThreadBasic/Synchronized/SynStatic
         7: dup
         8: invokespecial #6                  // Method "<init>":()V
        11: invokespecial #7                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
        14: astore_1
        15: aload_1
        16: invokevirtual #8                  // Method java/lang/Thread.start:()V
        19: aload_1
        20: invokevirtual #9                  // Method java/lang/Thread.join:()V
        23: return
      LineNumberTable:
        line 19: 0
        line 21: 15
        line 23: 19
        line 24: 23
    Exceptions:
      throws java.lang.InterruptedException

  static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=1, locals=0, args_size=0
         0: iconst_0
         1: putstatic     #2                  // Field i:I
         4: return
      LineNumberTable:
        line 4: 0
}
SourceFile: "SynStatic.java"

synchronized修饰的静态方法也没有monitorenter指令和monitorexit指令，取得代之的是ACC_SYNCHRONIZED标识;

总结

synchronized修饰代码块的时候:
同步语句块的实现使用的是monitorenter 和 monitorexit 指令，其中monitorenter指令指向同步代码块的开始位置，monitorexit指令则指明同步代码块的结束位置；
synchronized修饰方法的时候：
synchronized修饰的方法并没有monitorenter指令和monitorexit指令，取而代之的是ACC_SYNCHRONIZED标识，该标识指明了该方法是一个同步方法，JVM通过该ACC_SYNCHRONIZED访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。

richard1230
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第15讲 synchronized和ReentrantLock有什么区别呢？1
08-03
synchronized可以通过修饰方法或包裹代码块来实现同步。当一个线程获得对象的监视器锁后，其他尝试获取该锁的线程会被阻塞，直到锁被释放。synchronized方法或代码块的执行具有原子性，确保了多线程环境中的数据一致...
Java多线程（三）------深度解析：synchronized修饰方法与代码块的区别
weixin_44431073的博客
10-15 1344
初学多线程，肯定会接触同步。我们知道synchronized关键词可以修饰代码块，也可以修饰方法。那么具体修饰有什么区别呢？ 一、含义 关于含义的资料随便一搜就是一大把，我在这里列出一篇文章的介绍： synchronized 是同步锁，用来实现互斥同步。 在 Java 中，关键字 synchronized 可以保证在同一个时刻，只有一个线程可以执行某个方法或者某个代码块（主要是对方法或者代码块中存在共享数据的操作）。 syn...
synchronized底层如何实现的？用在代码块和方法上有什么区别？
qq_32534441的博客
04-25 1013
Java不可重入锁和可重入锁理解: https://blog.csdn.net/qq_32534441/article/details/88363851 synchronized 是可重入锁吗？为什么？ https://blog.csdn.net/qq_32534441/article/details/88363905 一张图讲解对象锁和关键字synchronized修饰方法(代码块) https...
深入理解使用synchronized同步方法和同步代码块的区别
ssdssa的博客
03-16 2812
一.代码块和方法之间的区别 首先需要知道代码块和方法有什么区别： 构造器和方法块，构造器可以重载也就是说明在创建对象时可以按照不同的构造器来创建，那么构造器是属于对象，而代码块呢他是给所有的对象初始化的。底下看一个列子： package com.bgi; public class Constructor_Methodblock { private int num; private String str; //构造器 public Constructor_Methodblo
「 并发编程技术 」剖析Synchronized修饰方法与代码块的区别（附详细代码案例解析）
frozenpenguin的博客
07-11 3959
Synchronized是Java中用于实现线程同步的一种机制，可以用来保证多线程访问共享资源的安全性。在Synchronized机制中，我们可以将Synchronized关键字修饰在方法上或者使用同步代码块来实现线程同步。但是，Synchronized修饰方法与同步代码块之间存在一些区别，本文将深入探讨它们的底层原理。
synchronized的修饰方法和修饰代码块区别
热门推荐
TesuZer的博客
07-01 2万+
文章思路 哪些概念难理解 类锁和对象锁区别 类锁所有对象一把锁 对象锁一个对象一把锁，多个对象多把锁 同步是对同一把锁而言的，同步这个概念是在多个线程争夺同一把锁的时候才能实现的，如果多个线程争夺不同的锁，那多个线程是不能同步的 两个线程一个取对象锁，一个取类锁，则不能同步 两个线程一个取a对象锁，一个取b对象锁，则不能同步 文章关键内容： 什么是锁 锁有几种 什么是synchroni...
Java并发编程：Synchronized及其实现原理
12-22
Synchronized还可以用于修饰代码块，指定锁定的对象。这样可以更细粒度地控制同步，提高并发性能。示例如下： ```java public class SynchronizedTest { private Object lock = new Object(); public void method...
深入理解Java并发之synchronized实现原理.docx
06-27
在Java对象头中，包含了一个指向Monitor的指针，当线程尝试进入同步代码块或方法时，如果锁未被持有，线程会被阻塞并等待；当锁被释放时，等待的线程会尝试重新获取锁并继续执行。 Java虚拟机对synchronized进行了...
Lock接口与synchronized关键字
最新发布
04-19
当线程进入synchronized修饰的方法或代码块时，会自动获取锁，并在退出时自动释放锁。而Lock接口则是一个更底层的同步机制，它提供了更丰富的功能，但需要显式地获取和释放锁，通常通过实现类如ReentrantLock来使用...
Java并发底层实现原理学习心得
08-28
同步方法通过在方法前加上synchronized关键字，而同步代码块则指定一个对象作为锁，对代码块进行同步。同步方法根据是否为静态方法，锁定的对象不同，普通方法锁定的是当前实例对象，静态方法锁定的是当前类的Class...
synchronized 加在方法和代码块底层实现区别
weixin_30722589的博客
10-10 351
1、同步方法块 被括起来的块分别有指令：monitorenter 和monitorexit monitorenter: 从之前的笔记知道，每个对象都有一个监视器锁(monitor)，当monitor被占用时就会处于锁定状态。线程就是执行monitorenter命令获取monitor锁的。 　　1、如果monitor的进入数为0，则线程获取锁，并设置monitor的进入数为1 　　2、如...
synchronized 修饰方法和修饰代码块的区别
关注移动端、Web、微信小程序等大前端领域
09-29 2198
主要是锁不同。 修饰方法时，对于静态方法，是把 class 作为锁；对于非静态方法，是把 this 对象当做锁； 修饰代码块时，是把任何对象作为锁，如果锁对象为空，会抛出 NullPointerException，但是修饰方法不会； 在锁的作用区域上，修饰方法时是整个方法体；而修饰代码块时只有对应的代码块。后者更加灵活和细粒度。 可以把修饰方法看作是修饰代码块的一种特殊形式，一种快捷方式。 ...
Synchronized修饰方法和同步代码块的区别
askcto的博客
04-12 1813
问题出现 Synchronized修饰方法和同步代码块的区别 Synchronized修饰方法的底层实现原理 Synchronized修饰同步代码块底层实现原理 代码验证 synchronized用法我们知道可以修饰实例方法，也可以修饰静态方法，还可以使用同步代码块。 public class Service { //synchronized修饰实例方法 synchronized...
java中synchronized修饰的方法或代码块和static synchronized修饰方法或代码块的区别
依然猴哥的博客
08-08 1976
例如：现在有两个方法 public class MyService { synchronized public void methodA() throws InterruptedException { System.out.println("start methodA ~~~~"); Thread.sleep(2000); System
Java基础之《synchronized关键字用在方法和代码块上的区别》
csj50的专栏
03-09 6556
在Java语言中，每一个对象有一把锁。线程可以使用synchronized关键字来获取对象上的锁。synchronized关键字可应用在方法级别(粗粒度锁)或者是代码块级别(细粒度锁)。问题的由来：看到这样一个面试题：//下列两个方法有什么区别 public synchronized void method1(){} public void method2(){ synchronized (...
一张图讲解对象锁和关键字synchronized修饰方法(代码块)
阿飞云漫步
09-29 1万+
每个对象在出生的时候就有一把钥匙（监视器Monitor），那么被synchronized 修饰的方法相当于给方法加了一个锁，这个方法就可以进行同步，在多线程的时候，不会出现线程安全问题。 注：Monitor是 Java中用以实现线程之间的互斥与协作的主要手段，它可以看成是对象或者 Class的锁。每一个对象都有，也仅有一个 Monitor。
字节码指令看Synchronized修饰方法和静态代码块的区别
qq_37856133的博客
04-26 145
原文：https://blog.csdn.net/askcto/article/details/105473452 如有侵权，请联系我删除
Synchronized底层原理
07-28
Synchronized是Java中用于实现线程同步的关键字。...需要注意的是，synchronized关键字可以修饰方法、代码块以及静态方法，它们在底层的实现上有一些细微的差别，但基本原理是相同的：通过监视器锁来实现线程的同步。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值