Java的锁事

于 2023-05-02 20:55:00 发布
阅读量570 收藏
点赞数
分类专栏： java 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouhe_/article/details/130466871
版权

乐观锁和悲观锁

悲观锁

认为自己在使用数据的使用一定有别的线程来修改数据，因此在获取数据的时候会先加锁，确保数据不会被别的线程修改

synchronized关键字和Lock的实现都是悲观锁

适合写操作多的场景，先加锁可以保证写操作时数据正确

乐观锁

认为自己在使用数据时不会有别的线程修改数据或资源，所以不会加锁

在java中通过使用无锁编程来实现，知识在更新数据的时候去判断，之前没有别的线程更新了这个数据

如果这个数据没有被更新，当前线程将自己修改的数据成功写入

如果这个数据已经被其他线程更新，则根据不同的实现方式执行不同的操作，比如放弃修改、重试抢锁等等

判断规则

  1. 版本号机制version
  2. 最常采用CAS算法，java原子类中的递增操作就是通过CAS自炫实现的

适合读多的场景，不加锁的特点能够使其读操作的性能大幅度提升

8锁案例

请添加图片描述

  • class Phone{// 资源类
    public synchronized void sendEmail()
    {
        System.out.println("------sendEmail");
    }
    public synchronized void sendSMS()
    {
        System.out.println("------sendSMS");
    }
}

/**
 * 题目：谈谈您对多线程锁的理解，8锁案例说明
 * 口诀： 线程 操作 资源类
 * 8锁案例说明：
 * 1. 标准访问有ab两个线程，请问先打印邮件还是短信
 * 2. sendEmail方法中加入暂停3秒钟，请问先打印邮件还是短信
 * 3. 添加一个普通的hello方法，请问先打印邮件还是短信
 * 4. 有两部手机，请问先打印邮件还是短信
 * 5. 有2个静态同步方法，有1部手机，请问先打印邮件还是短信
 * 6. 有2个静态同步方法，有2部手机，请问先打印邮件还是短信
 * 7. 有1个静态同步方法，有1个普通方法，有1部手机，请问先打印邮件还是短信
 * 8. 有1个静态同步方法，有1个普通方法，有2部手机，请问先打印邮件还是短信
 */
public class Lock8Demo {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> {
            phone.sendEmail();},"a").start();

        TimeUnit.MILLISECONDS.sleep(200);
        new Thread(() -> {
            phone.sendSMS();},"b").start();


    }
}

  • class Phone{// 资源类
    public synchronized void sendEmail()
    {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("------sendEmail");
    }
    public synchronized void sendSMS()
    {
        System.out.println("------sendSMS");
    }
}

/**
 * 题目：谈谈您对多线程锁的理解，8锁案例说明
 * 口诀： 线程 操作 资源类
 * 8锁案例说明：
 * 1. 标准访问有ab两个线程，请问先打印邮件还是短信
 * 2. sendEmail方法中加入暂停3秒钟，请问先打印邮件还是短信
 * 3. 添加一个普通的hello方法，请问先打印邮件还是短信
 * 4. 有两部手机，请问先打印邮件还是短信
 * 5. 有2个静态同步方法，有1部手机，请问先打印邮件还是短信
 * 6. 有2个静态同步方法，有2部手机，请问先打印邮件还是短信
 * 7. 有1个静态同步方法，有1个普通方法，有1部手机，请问先打印邮件还是短信
 * 8. 有1个静态同步方法，有1个普通方法，有2部手机，请问先打印邮件还是短信
 */
public class Lock8Demo {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> {
            phone.sendEmail();},"a").start();

        TimeUnit.MILLISECONDS.sleep(200);
        new Thread(() -> {
            phone.sendSMS();},"b").start();


    }
}

    一个对象里面如果有多个synchronized方法，某一个时刻，只要有一个线程去调用 其中一个synchronized方法 了，其他的线程只能等待，换句话说，某一个时刻，只能有唯一的一个线程去访问这些synchronized方法，锁的是当前对象的this，被锁定后，其他的线程都不能进入到当前对象的其他的synchronized方法

  • class Phone{// 资源类
    public synchronized void sendEmail()
    {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("------sendEmail");
    }
    public synchronized void sendSMS()
    {
        System.out.println("------sendSMS");
    }
    public void hello()
    {
        System.out.println("hello world");
    }
}

/**
 * 题目：谈谈您对多线程锁的理解，8锁案例说明
 * 口诀： 线程 操作 资源类
 * 8锁案例说明：
 * 1. 标准访问有ab两个线程，请问先打印邮件还是短信
 * 2. sendEmail方法中加入暂停3秒钟，请问先打印邮件还是短信
 * 3. 添加一个普通的hello方法，请问先打印邮件还是短信
 * 4. 有两部手机，请问先打印邮件还是短信
 * 5. 有2个静态同步方法，有1部手机，请问先打印邮件还是短信
 * 6. 有2个静态同步方法，有2部手机，请问先打印邮件还是短信
 * 7. 有1个静态同步方法，有1个普通方法，有1部手机，请问先打印邮件还是短信
 * 8. 有1个静态同步方法，有1个普通方法，有2部手机，请问先打印邮件还是短信
 */
public class Lock8Demo {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> {
            phone.sendEmail();},"a").start();

        TimeUnit.MILLISECONDS.sleep(200);
        new Thread(() -> {
            phone.hello();
            },"b").start();


    }
}

应该是如您所愿哈哈，资源类 这个概念很好

  • class Phone{// 资源类
    public synchronized void sendEmail()
    {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("------sendEmail");
    }
    public synchronized void sendSMS()
    {
        System.out.println("------sendSMS");
    }
    public void hello()
    {
        System.out.println("hello world");
    }
}

/**
 * 题目：谈谈您对多线程锁的理解，8锁案例说明
 * 口诀： 线程 操作 资源类
 * 8锁案例说明：
 * 1. 标准访问有ab两个线程，请问先打印邮件还是短信
 * 2. sendEmail方法中加入暂停3秒钟，请问先打印邮件还是短信
 * 3. 添加一个普通的hello方法，请问先打印邮件还是短信
 * 4. 有两部手机，请问先打印邮件还是短信
 * 5. 有2个静态同步方法，有1部手机，请问先打印邮件还是短信
 * 6. 有2个静态同步方法，有2部手机，请问先打印邮件还是短信
 * 7. 有1个静态同步方法，有1个普通方法，有1部手机，请问先打印邮件还是短信
 * 8. 有1个静态同步方法，有1个普通方法，有2部手机，请问先打印邮件还是短信
 */
public class Lock8Demo {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        new Thread(() -> {
            phone.sendEmail();},"a").start();

        TimeUnit.MILLISECONDS.sleep(200);
        new Thread(() -> {
            phone2.sendSMS();
            },"b").start();
    }
}

    两部手机当然喽

  • class Phone{// 资源类
    public static synchronized void sendEmail()
    {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("------sendEmail");
    }
    public static synchronized void sendSMS()
    {
        System.out.println("------sendSMS");
    }
    public void hello()
    {
        System.out.println("hello world");
    }
}

/**
 * 题目：谈谈您对多线程锁的理解，8锁案例说明
 * 口诀： 线程 操作 资源类
 * 8锁案例说明：
 * 1. 标准访问有ab两个线程，请问先打印邮件还是短信
 * 2. sendEmail方法中加入暂停3秒钟，请问先打印邮件还是短信
 * 3. 添加一个普通的hello方法，请问先打印邮件还是短信
 * 4. 有两部手机，请问先打印邮件还是短信
 * 5. 有2个静态同步方法，有1部手机，请问先打印邮件还是短信
 * 6. 有2个静态同步方法，有2部手机，请问先打印邮件还是短信
 * 7. 有1个静态同步方法，有1个普通方法，有1部手机，请问先打印邮件还是短信
 * 8. 有1个静态同步方法，有1个普通方法，有2部手机，请问先打印邮件还是短信
 */
public class Lock8Demo {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        new Thread(() -> {
            phone.sendEmail();},"a").start();

        TimeUnit.MILLISECONDS.sleep(200);
        new Thread(() -> {
            phone.sendSMS();
//            phone2.sendSMS();
            },"b").start();
    }
}

    5-6 都换成静态同步方法后，情况又有变化

    三种synchronized锁的内容有一些差别：

    对于普通同步方法，锁的是当前实例对象，通常是指this，具体的一部手机，所有的普通同步方法用的都是同一把锁–>实例对象本身

    对于静态同步方法，锁的是当前类的Class对象，如Phone.class唯一的一个模版

    对于同步方法块，锁的是synchronized括号内的对象

  • class Phone{// 资源类
    public static synchronized void sendEmail()
    {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("------sendEmail");
    }
    public   synchronized void sendSMS()
    {
        System.out.println("------sendSMS");
    }
    public void hello()
    {
        System.out.println("hello world");
    }
}

/**
 * 题目：谈谈您对多线程锁的理解，8锁案例说明
 * 口诀： 线程 操作 资源类
 * 8锁案例说明：
 * 1. 标准访问有ab两个线程，请问先打印邮件还是短信
 * 2. sendEmail方法中加入暂停3秒钟，请问先打印邮件还是短信
 * 3. 添加一个普通的hello方法，请问先打印邮件还是短信
 * 4. 有两部手机，请问先打印邮件还是短信
 * 5. 有2个静态同步方法，有1部手机，请问先打印邮件还是短信
 * 6. 有2个静态同步方法，有2部手机，请问先打印邮件还是短信
 * 7. 有1个静态同步方法，有1个普通方法，有1部手机，请问先打印邮件还是短信
 * 8. 有1个静态同步方法，有1个普通方法，有2部手机，请问先打印邮件还是短信
 */
public class Lock8Demo {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        new Thread(() -> {
            phone.sendEmail();},"a").start();

        TimeUnit.MILLISECONDS.sleep(200);
        new Thread(() -> {
            phone.sendSMS();
//            phone2.sendSMS();
            },"b").start();
    }
}

    7-8结果

    一个是类锁，一个是对象锁，你说呢

Synchronized体现

作用与实例方法，当前实例加锁，进入 同步代码前要获得当前实例的锁；

作用于代码块，对括号里配置的对象加锁；

作用于静态方法，当前类加锁，进去同步代码前要获得当前类对象的锁

Synchronized字节码实现

java -c ***.classs 文件反编译

synchronzied 同步代码块

请添加图片描述

保证异常情况下，程序退出

一般情况下，一个enter两个exit

极端：在程序中手动抛出异常

synchronized 普通同步方法

请添加图片描述

调用指令将会检查方法的ACC—SYNNCHRONIZED访问标志是否设置。

如果设置了，执行线程会将现持有monitor锁，然后再执行方法，最后在方法完成（无论是正常完成还是非正常完成）时释放monitor

synchronized 静态同步方法

请添加图片描述

ACC_STATIC,ACC_SYNCHRONIZED访问标志区分该方法是否时静态同步方法

反编译synchronized锁的是什么

面试题：为什么任何一个对象都可以成为一个锁

public class ThreadTest {
    Object o = new Object();
    public void m1()
    {
        synchronized (o){
            System.out.println("hello world");
        }
    }
    public static void main(String[] args) {
        
    }
}

在HotSpot虚拟机中，monitor采用ObjectMonitor实现

ObjectMonitor.java->ObjectMonitor.cpp->objectMonitor.hpp

每个对象天生都带着一个对象监视器

每个被锁的对象都会和Monitor关联起来

公平锁与非公平锁

公平锁：多个线程按照申请锁的顺序来获取锁，这里类似排队买票，先来的人先买后来的人在队尾排着，这是公平的Lock lock = new ReentrantLock(true);// true 表示公平锁，先来先得

非公平锁：是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，在高并发环境下，有可能造成优先级翻转或者饥饿状态（某个线程一致得不到锁）

Lock lock = new ReentrantLock（false）;// false 表示非公平锁，后来的也可能先获得锁，默认非公平锁

为什么会有公平锁/非公平锁的设计？为什么默认非公平锁？

  1. 恢复挂起的线程到真正锁的获取还是有时间差的，从开放人员来看这个时间微乎其微，但是从cpu的角度来看，这个时间存在的还是很明显的。所以非公平锁能更充分的利用cpu的时间片，尽量减少cpu空闲状态时间。
  2. 使用多线程很重要的考量点事线程切换的开销，当采用非公平锁，当1个线程请求锁获取锁的同步状态，然后释放同步状态，所以刚释放锁的线程在此刻在此获取锁同步状态的概率就变得非常大，所以就减少了了线程开销

什么时候用公平？什么时候非公平？

如果为了吞吐量，使用非公平，否则，公平锁

可重入锁（又名递归锁）

是指同一个线程在外层方法获取锁的时候，再进入该线程内层方法会自动获取到锁（前提，锁对象得是同一个对象），不会因为之前已经获取过还没释放而阻塞

如果是1个有synchronized修饰得递归调用方法，程序第2次进入被自己阻塞岂不是天大的笑话，出现了作茧自缚。

所以，java中的ReentrantLock和Synchronized都是可重入锁，可重入锁的一个优点是可以一定程度避免死锁

隐式重入锁（synchronized）

原理

每隔锁对象拥有一个锁计数器和一个指向持有该锁的线程的指针。

当执行monitorenter时，如果目标锁对象的计数器为零，那么说明他没有被其他线程所持有，java虚拟机会将该锁对象持有线程设置为当前线程，并且将其计数器+1

在目标锁对象的计数器不为零的情况下，如果锁对象的持有线程是当前线程，那么java虚拟集可以将其计数器+1，否则则需要等待，直至持有线程释放该锁

当执行monitorexit时，java虚拟机则需要将锁对象的计数器-1。计数器为零代表所以被释放

显式重入锁（Lock）

死锁

请添加图片描述

死锁是指两个或两个以上的线程再执行过程中，因为争夺资源而造成的一种互相等待的现象，若无外力干涉他们将无法推荐下去，如果胸资源充足，进程的资源请求都能够得到满足，死锁出现的肯能行就很低，否则就会因为争夺有限的资源而陷入死锁

模拟死锁

public static void main(String[] args) {
    final Object a = new Object();
    final Object b = new Object();

    new Thread(() -> {
        synchronized (a) {
            System.out.println("A锁");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (b){
                System.out.println("A获取到B锁");
            }
        }
    }).start();
    new Thread(() -> {
        synchronized (b) {
            System.out.println("B锁");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (a){
                System.out.println("B获取到A锁");
            }
        }
    }).start();
}

检测死锁

命令

​ jps

​ jstack

图形化

​ jconsole

主要原因

系统资源不足；

进程运行推进的顺序不合适

资源分配不当

归去来兮★
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java琐事
zfx2013的博客
08-01 295
并发编程 并发的意义 并发通常是提高运行在单处理器上的程序的性能。如果程序中的某个任务因为该程序控制范围之外的某些条件(I/O)而导致不能继续执行，那么这个任务或线程就阻塞了。如果没有并发，整个程序都讲停下来。从性能的角度来看，单处理器上使用并发没有任何好处。 进程与线程 实现并发有两种方式，多进程与多线程，最直接的方式是使用操作系统级别的进程。进程是运行在它自己地址空间内的自包容的程序。多任务操作系统可以周期性地将CPU从一个进程切换到另一个进程，来实现多进程。操作系统会将多进程隔离开，保证互相不会干涉。
TrueGlobalCitizenQuiz：使用Java构建的简单Android琐事应用
02-17
真正的全球公民测验 这是一个简单的Android应用程序，可循环显示五个正确/错误问题 这是我第一次尝试使用Android应用，因此，我想保持简单 它是在线性视图上设计的，并利用Toast判断答案是否正确 ...
第四章：Java琐事
YZG ' BLOG
11-25 579
指针指向monitor对象（也称为管程或监视器锁）的起始地址。每个对象都存在着一个monitor与之关联，当一个monitor被某个线程持有后，它便处于锁定状态。在Java虚拟机(HotSpot)中，monitor是由ObjectMonitor实现的，其主要数据结构如下（位于HotSpot虚拟机源码ObjectMonitor.hpp,C++实现的）指针指向monitor对象（也称为管程或监视器锁）的起始地址。每个对象都存在着一个monitor与之关联，当一个monitor被某个线程持有后，它便处于锁定状态。
您对Java琐事的了解程度如何？
06-16 114
Java技术已经进步，并且在过去十年中变得非常强大。 这种持久的编程语言由于充分的理由仍然非常受欢迎。 它是安全，简单且强大的。 但这只是冰山一角。 让我们测试您的知识，并确定您是否真的了解Java。 让我们开始思考问题！ Java最初叫什么？ a。）橡树 b。）云杉 c。）拿铁 d。）柴 答： a）橡树！ Java的最早版本被称为Oak。 它的灵感来自Java首席创建者J...
Java多线程与高并发琐事
weixin_42002747的博客
08-01 143
多线程 进程 进程同步机制 共享内存 信号量 管道 消息队列 套接字 进程的状态和转换 运行、就绪、等待 守护进程 守护进程就是在后台运行,不与任何终端关联的进程, 通常情况下守护进程在系统启动时就在运行, 它们以root用户或者其他特殊用户(apache和 postfix)运行,并能处理一些系统级的任务. 孤儿进程 如果父进程先退出,子进程还没退出那么子进程将被 托孤给init进程 僵尸进程 一个进程已经终止了,但是其父进程还没有获取其状态 如何避免 在父进程
您的日常琐事就是我们的_您对Java琐事的了解程度如何？
07-08 140
您的日常琐事就是我们的 Java技术已经发展，并且在过去十年中变得非常强大。 这种持久的编程语言由于充分的理由仍然非常受欢迎。 它是安全，简单且强大的。 但这只是冰山一角。 让我们测试您的知识，了解您是否真的了解Java。 让我们开始讨论问题！ Java最初叫什么？ a。）橡树 b。）云杉 c。）拿铁 d。）柴 答： a）橡树！ Java的最早版本被称为Oak。 它的灵感来自...
java爱心效果代码来了
热门推荐
淡沫初夏zz的博客
04-18 11万+
Java爱心代码来了
java基础
泰勒今天想展开的博客
04-24 236
（一）Java中，变量，常量，定义原则 1.1定义原则： 所有变量，方法，类名：见名知意 类成员变量：首字母小写和驼峰原则：monthSalary 局部变量:首字母小写与驼峰原则 常量:全大写和下滑线分割：MAX_VALUE 类名:首字母大写与驼峰原则：Man,GoodMan 方法名:首字母小写和驼峰原则:run(),runRun() 1.2变量的定义： 变量的本质（固定空间）：停车位,空间已经确定，但具体放置哪量车不确定。 变量名（通过名字操作空间）：停车位编号 数据（变化的量）：车 1.3常量定
java多线程
微风吹付博客
11-08 356
零、前言 由于一些技术点不太常用或业务上不需要使用，所以变成生疏或遗忘。最近有些时间了，整理了一下，简单的记录下来，做个笔记。越发觉得只有写下来的东西才不会被遗忘。 一、如何创建一个线程 我知道的常用的就是一共三种方式（还有两种是线程池）， 要注意如果继承Runnable的话，线程启动时要使用thread.run， 而不是thread.start，如下: 另外可以通过线程池来Executors.newXXXThread(); 或者可以使用new ForkJoin(num); public class
那些琐事
qq_23095607的博客
03-14 149
一.概况 锁按照大类分为线程锁和进程锁，此文现只讨论线程锁 二.分类 1.线程是否要锁住同步资源： 锁住：悲观锁 不锁住: 乐观锁 CAS 2.锁住同步资源失败，线程是否要阻塞： 阻塞 不阻塞： 自旋锁 适应性自旋锁 3.多个线程竞争同步资源的流程细节有没有区别： 不锁住资源，多个线程中只有一个能修改资源成功，其他线程会重试： 无锁 同一个线程执行同步资源时自动获取资源： 偏向锁 多个线程竞争同步...
小红书java_java技巧
weixin_36320737的博客
02-15 351
Hello大家好～我是yiyu[萌萌哒R]先给大家鞠个躬[飞吻R]毕竟一日之间粉丝“暴涨”400多对人海中像我这样的小透明来说真的是受宠若惊。不过有可能会让大家失望的是，我不会频繁更博或者小红书[哭惹R]。一是因为每日的生活两点一线，学业压力又比较重，的确难以抽出时间；二是因为学习心得的分享与好物分享不同，需要多年的积累和沉淀，不可能常换常新，因此就我个人来说，短期内能分享的也着实有限。说到这儿觉...
Maze_Trivia:使用 Java 实现的迷宫琐事游戏。 用于 GUI 的 LibGDX 库和用于数据库实现的 SQL Lite
05-31
迷宫琐事 使用 Java 实现的迷宫琐事游戏。 用于 GUI 的 LibGDX 库和用于数据库实现的 SQL Lite。
FBLA:FBLA琐事游戏
06-06
FBLA FBLA琐事游戏FBLA Trivia Game 是为 2013 年州比赛而制作的项目，并在那里获得了第一名。
quizzard:技术琐事API
03-05
测验 技术琐事API
src_JAVA源码_
09-29
JAVA实训作品 这是一个界面简单的java记事本，界面友好，...这是一个简单的文字编辑器，日常生活的大小琐事记录上面，工作行程安排，可当做笔记本使用。界面为纯白色。关键字：java记事本，记事本类，界面，方法，事件
线程 安全
zhouhe_的博客
12-25 2246
线程安全 例子： public class Test { private static int num = 0; public static void main(String[] args) { Thread thread1 = new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 100000000; i++) {
类与类之间的关系-继承
zhouhe_的博客
05-20 1999
类与类之间的关系 A is-a B 泛化 （继承 实现） A has-a B 包含 （组合 聚合 关联） A use-a B 依赖 （依赖） 类关系设计：高内聚 低耦合 ：继承（实现）>组合>聚合>关联 > 依赖 继承 1.子类继承父类，通过一个关键字 extends 2.子类对象可以调用父类中的（public protected）属性和方法 当作自己的来使用 3.子类可以添加自己独有的属性和方法 4.子类从父类中继承过来的方法不能满足子类需要，可以在子类中
FlinkSql+Stream综合使用+广播流
zhouhe_的博客
11-22 1990
FlinkSql+Stream综合使用+广播流
Flink之ProcessFunction
zhouhe_的博客
11-23 1459
ProcessFunction
java超市商品管理系统
最新发布
12-26
Java超市商品管理系统是一个基于Java语言开发的系统，旨在帮助超市管理员更好地管理商品信息和日常琐事。该系统包含以下功能模块： 1. 用户登录注册：提供普通用户和VIP用户的登录和注册功能，确保用户身份的安全和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值