第四章：Java琐事

已于 2022-12-28 11:01:21 修改
阅读量588 收藏
点赞数
分类专栏： # JUC高级 文章标签： java jvm
于 2022-11-25 21:28:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aetawt/article/details/128044910
版权

乐观锁和悲观锁

悲观锁

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

  • 悲观锁的实现方式

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

  • 适合写操作多的场景，先加锁可以保证写操作时数据正确。显示的锁定之后再操作同步资源。

//=============悲观锁的调用方式
public synchronized void m1()
{
    //加锁后的业务逻辑......
}

// 保证多个线程使用的是同一个lock对象的前提下
ReentrantLock lock = new ReentrantLock();
public void m2() {
    lock.lock();
    try {
        // 操作同步资源
    }finally {
        lock.unlock();
    }
}

乐观锁

  • 乐观锁认为自己在使用数据时不会有别的线程修改数据，所以不会添加锁，只是在更新数据的时候去判断之前有没有别的线程更新了这个数据。如果这个数据没有被更新，当前线程将自己修改的数据成功写入。如果数据已经被其他线程更新，则根据不同的实现方式执行不同的操作
  • 乐观锁的实现方法：
    • 版本号机制Version。（只要有人提交了就会修改版本号，可以解决ABA问题）
    • 最常采用的是CAS算法，Java原子类中的递增操作就通过CAS自旋实现的。
  • 适合读操作多的场景，不加锁的性能特点能够使其操作的性能大幅提升。
//=============乐观锁的调用方式
// 保证多个线程使用的是同一个AtomicInteger
private AtomicInteger atomicInteger = new AtomicInteger();
atomicInteger.incrementAndGet();

八种案例演示synchronized到底锁的是什么

阿里巴巴多锁的要求：

  • 【强制】高并发时，同步调用应该去考量锁的性能损耗。能用无锁数据结构，就不要用锁；能锁区块，就不要锁整个方法体；能用对象锁，就不要用类锁。
  • 简单一句话：能不用就不用，即使用尽量将 synchronized 的同步代码快缩小。

演示八种案例：

/**
 *
 * Author: YZG
 * Date: 2022/11/13 21:22
 * Description:
 * 1 标准访问，先打印短信还是邮件
 * --------- sendSMS
 * --------- sendEmail
 *
 * 2停4秒在短信方法内，先打印短信还是邮件
 * --------- sendSMS
 * --------- sendEmail
 * 3新增普通的hello方法,是先打短信还是hello
 *
 * --------- sendHello
 * --------- sendSMS
 * 4现在有两部手机，先打印短信还是邮件
 *
 *--------- sendEmail
 * --------- sendSMS
 *
 * 5两个静态同步方法, 1部手机,先打印短信还是邮件
 *--------- sendSMS
 * --------- sendEmail
 *
 * 6两个静态同步方法, 2部手机，先打印短信还是邮件
 *--------- sendSMS
 * --------- sendEmail
 *
 * 7 1个静态同步方法1个普通同步方法，1部手机，先打印短信还是邮件
 *--------- sendEmail
 * --------- sendSMS
 *
 * 8 1个静态同步方法, 1个普通同步方法, 2部手机,先打印短信还是邮件
 *--------- sendEmail
 * --------- sendSMS
 */
public class Demo06 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        // Phone phone2 = new Phone();

        new Thread(Phone::sendEMS,"t1").start();

        TimeUnit.MILLISECONDS.sleep(20);

        new Thread(phone::sendEmail,"t2").start();
    }
}

class Phone {

    public synchronized void sendEMS(){
        // try {
        //     TimeUnit.SECONDS.sleep(4);
        // } catch (InterruptedException e) {
        //     e.printStackTrace();
        // }
        System.out.println("--------- sendSMS");
    }

    public  synchronized  void sendEmail() {
        System.out.println("--------- sendEmail");
    }

    public  void sendHello() {
        System.out.println("--------- sendHello");
    }
}

总结

  • 对于普通同步方法，锁是当前实例对象。
  • 对于静态同步方法，锁是当前类的Class对象。
  • 对于同步方法块,锁是Synchoni zed括号里配置的对象

字节码角度分析 Synchronized

反编译指令：

  • 文件反编译javap -c ***.class文件反编译，-c表示对代码进行反汇编

  • 假如需要更多信息 javap -v ***.class ，-v即-verbose输出附加信息（包括行号、本地变量表、反汇编等详细信息）

JVM 指令的学习笔记： JVM

synchronized 同步代码块

代码

public class LockSyncTest {

    private Object obj = new  Object();

    public void m1() {
        synchronized (obj) {
            System.out.println("hello");
        }

    }

    public static void main(String[] args) {

    }
}

字节码

image-20221121162454284

结论：

synchronized 经过编译之后，会在同步代码块前后生成 monitorenter 和 monitorexit 俩个指令。在执行 monitorenter 指令时，会尝试获取对象锁，如果对象锁被占用，或者锁对象的持有线程是当前线程，锁的计数器就会 +1，响应的执行 monitorexit 指令时，锁的计数器会 -1 ， 计数器为 0 时 表示 锁已经被释放。

第二个 monitorexit 是为了防止同步代码块出现异常。

synchronized 同步方法

代码：

    public synchronized void m2() {
            System.out.println("hello");

    }

字节码；

image-20221121163633383

image-20221121163739471

结论：

通过字节码我们可以看，同步方法是隐式的，不需要JVM生成字节码指令，在是在访问标志中指出。调用方法时，调用指令会检查方法的 ACC_ SYNCHRONIZED 访问标志是否设置。

  • 如果设置了，执行线程将先持有同步锁，然后执行方法。最后在方法完成(无论是正常完成还是非正常完成)时释放同步锁。

静态同步方法与普通同步方法的区别就是访问标识中加了 static

image-20221121164119749

为什么任意一个对象都可以是锁？

在 Java 中任意一个对象都可以是锁，这是为什么呢？

多线程的锁，其实本质上就是给一块内存空间的访问添加访问权限，因为Java中是没有办法直接对某一块内存进行操作的，又因为Java是面向对象的语言，一切皆对象，所以具体的表现就是某一个对象承担锁的功能，每一个对象都可以是一个锁。

其实看到对象的内存结构就很清晰明了，每个对象的对象头都包含 锁状态标志 和 线程持有的锁

image-20221121165342470

另一方面，从C源码中可以看出：

  • ObjectMonitor.java→ObjectMonitor.cpp→objectMonitor.hpp
    • ObjectMonitor.cpp中引入了头文件，（include）objectMonitor.hpp
140行
  ObjectMonitor() {
    _header       = NULL;
    _count        = 0; //用来记录该线程获取锁的次数
    _waiters      = 0,
    _recursions   = 0;//锁的重入次数
    _object       = NULL;
    _owner        = NULL; //------最重要的----指向持有ObjectMonitor对象的线程，记录哪个线程持有了我
    _WaitSet      = NULL; //存放处于wait状态的线程队列
    _WaitSetLock  = 0 ;
    _Responsible  = NULL ;
    _succ         = NULL ;
    _cxq          = NULL ;
    FreeNext      = NULL ;
    _EntryList    = NULL ;//存放处于等待锁block状态的线程队列
    _SpinFreq     = 0 ;
    _SpinClock    = 0 ;
    OwnerIsThread = 0 ;
    _previous_owner_tid = 0;
  }
  • 追溯底层可以发现每个对象天生都带着一个对象监视器。

公平锁和非公平锁

公平锁：多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。

  • 优点：所有的线程都能得到资源，不会饿死在队列中。
  • 缺点：吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的开销会很大。

非公平锁：多个线程去获取锁的时候，会直接去尝试获取，获取不到，再去进入等待队列，如果能获取到，就直接获取到锁。

  • 优点：可以减少CPU唤醒线程的开销，整体的吞吐效率会高点，CPU也不必取唤醒所有线程，会减少唤起线程的数量。
  • 缺点：可能导致队列中间的线程一直获取不到锁或者长时间获取不到锁，导致饿死。

synchronized 为非公平锁，ReentrantLock默认也是非公平锁，可通过设置参数 true 创建公平锁

买票案例代码：

//第一步  创建资源类，定义属性和和操作方法
class LTicket {
    //票数量
    private int number = 30;

    // 设置公平锁
    private final ReentrantLock lock = new ReentrantLock(true);
    //卖票方法
    public void sale() {
        //上锁
        lock.lock();
        try {
            //判断是否有票
            if(number > 0) {
                System.out.println(Thread.currentThread().getName()+" ：卖出"+(number--)+" 剩余："+number);
            }
        } finally {
            //解锁
            lock.unlock();
        }
    }
}

public class Demo07 {
    //第二步 创建多个线程，调用资源类的操作方法
    //创建三个线程
    public static void main(String[] args) {

        LTicket ticket = new LTicket();

        new Thread(()-> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"AA").start();

        new Thread(()-> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"BB").start();

        new Thread(()-> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"CC").start();
    }
}

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

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

可重入锁（递归锁）

什么是 “可重入”，可重入就是说某个线程已经获得某个锁，可以再次获取锁 (同一把锁) 而不会出现 死锁。

synchronized 和 ReentrantLock 都是可重入锁

隐式锁synchronized

同步代码块方式：

public class LockSyncTest02 {
    public static void main(String[] args) {
        Object o = new Object();
        new Thread(() -> {
            synchronized (o) {
                System.out.println(Thread.currentThread().getName() + " .....外层调用");
                synchronized (o) {
                    System.out.println(Thread.currentThread().getName() + " .....中层调用");
                    synchronized (o) {
                        System.out.println(Thread.currentThread().getName() + " .....内层调用");
                    }
                }
            }
        }, "t1").start();
    }
}

输出结果：

t1 .....外层调用
t1 .....中层调用
t1 .....内层调用

同步方法方式：

public class LockSyncTest02 {

    public synchronized void m1() {
        System.out.println(Thread.currentThread().getName() + " .....m1 come in");
        m2();
        System.out.println(Thread.currentThread().getName() + " .....m1 end");

    }

    private synchronized void m2() {
        System.out.println(Thread.currentThread().getName() + " .....m2 come in");
        m3();
        System.out.println(Thread.currentThread().getName() + " .....m2 end");

    }

    private synchronized void m3() {
        System.out.println(Thread.currentThread().getName() + " .....m3 come in");
        System.out.println(Thread.currentThread().getName() + " .....m3 end");

    }

    public static void main(String[] args) {
        LockSyncTest02 lockSyncTest02 = new LockSyncTest02();
        lockSyncTest02.m1();
    }
}

输出结果：

main .....m1 come in
main .....m2 come in
main .....m3 come in
main .....m3 end
main .....m2 end
main .....m1 end

Process finished with exit code 0

显示锁Lock

注意事项：

  • 由于Lock需要手动上锁释放锁，因此上锁和释放锁的次数一定要对应上。否则在多线程的场景下，很容易造成阻塞，甚至死锁。
public class Demo09 {
    public static void main(String[] args) {

        ReentrantLock lock = new ReentrantLock();
        try {
            lock.lock(); // 上锁
            System.out.println(Thread.currentThread().getName() + " 第一次获取锁");
            try {
                lock.lock(); // 上锁
                System.out.println(Thread.currentThread().getName() + " 第二次获取锁");
            } finally {
               lock.unlock(); // 解锁
            }
        } finally {
            lock.unlock(); // 解锁
        }
    }
}

演示 Lock 出现阻塞的情况：

由于主线程在第二次获取锁的时候，并没有手动释放锁，造成了t1线程一直处在阻塞状态

public class LockTest {
    public static void main(String[] args) {

        ReentrantLock lock = new ReentrantLock();
        try {
            lock.lock(); // 上锁
            System.out.println(Thread.currentThread().getName() + " 第一次获取锁");
            try {
                lock.lock(); // 上锁
                System.out.println(Thread.currentThread().getName() + " 第二次获取锁");
            } finally {
                // lock.unlock(); // 解锁
            }
        } finally {
            lock.unlock(); // 解锁
        }

        new Thread(() -> {
            lock.lock();
            System.out.println(Thread.currentThread().getName());
            lock.unlock();
        }, "t1").start();
    }
}

通过 jstack 命令查看 t1 线程的状态：

image-20221121174716248

image-20221121174643010一直在等待 main 线程释放锁。

死锁及排查

什么是死锁？

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。

image-20221121175456095

演示死锁

public class DeadLock {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();
        new Thread(() -> {
            synchronized (o1) {
                System.out.println(Thread.currentThread().getName() + " 占用 o1，试图获取o2");
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (o2) {
                    System.out.println(Thread.currentThread().getName() + " 占用 o2");
                }
            }
        }, "t1").start();


        new Thread(() -> {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 占用 o2，试图获取o1");
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (o1) {
                    System.out.println(Thread.currentThread().getName() + " 占用 o1");
                }
            }
        }, "t2").start();
    }
}

死锁产生的原因

  • 系统资源不足
  • 进程运行推进的顺序不合适
  • 资源分配不当

死锁的排查

更详细的JVM指令笔记： JVM

命令行

使用 jps + jstack

image-20221121180712515

可以看出死锁的线程：

image-20221121180743433

图形化界面

控制台输入 JConsole，弹出如图界面，它是jdk内置的一个监视控制台。

选中运行的类进行连接

image-20221121180900316

从这里也可以看出出现死锁

image-20221121181014482

总结

指针指向monitor对象（也称为管程或监视器锁）的起始地址。每个对象都存在着一个monitor与之关联，当一个monitor被某个线程持有后，它便处于锁定状态。在Java虚拟机(HotSpot)中，monitor是由ObjectMonitor实现的，其主要数据结构如下（位于HotSpot虚拟机源码ObjectMonitor.hpp,C++实现的）

在这里插入图片描述

以下相当于一些前置知识

写锁（独占锁）/读锁（共享锁）—— 见第十四章

自旋锁SpinLock —— 见第八章

无锁-独占锁-读写锁-邮戳锁 —— 见第十四章

无锁-偏向锁-轻量锁-重量锁 —— 见第十二章

各位彭于晏，如有收获点个赞不过分吧…✌✌✌

Alt

扫码关注公众号 【我不是秃神】 回复 JUC 可下载 MarkDown 笔记

鲨瓜2号
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
第十三章：文本聚类应用实战
程序员光剑
04-28 420
第十三章：文本聚类应用实战 1. 背景介绍 文本聚类作为自然语言处理 (NLP) 中的关键技术之一，在信息检索、主题发现、客户细分等领域发挥着重要作用。它能够将大量文本数据按照语义相似性进行分组，帮助我们从海量信息中提取有价值的知识和洞察。本章将深入探讨文本聚类的应用实战，涵盖核心概念、算法原理
java琐事
zfx2013的博客
08-01 315
并发编程 并发的意义 并发通常是提高运行在单处理器上的程序的性能。如果程序中的某个任务因为该程序控制范围之外的某些条件(I/O)而导致不能继续执行，那么这个任务或线程就阻塞了。如果没有并发，整个程序都讲停下来。从性能的角度来看，单处理器上使用并发没有任何好处。 进程与线程 实现并发有两种方式，多进程与多线程，最直接的方式是使用操作系统级别的进程。进程是运行在它自己地址空间内的自包容的程序。多任务操作系统可以周期性地将CPU从一个进程切换到另一个进程，来实现多进程。操作系统会将多进程隔离开，保证互相不会干涉。
java 琐 事
qq_25825923
02-15 144
https://cloud.tencent.com/developer/article/1363428
关于Java 中的那些“锁”事
程序员麦冬的博客（公众号同名）
09-22 203
一、公平锁&非公平锁 1.1公平锁是什么 公平锁：线程按照申请锁的顺序来获取锁；在并发环境中，每个线程都会被加到等待队列中，按照 FIFO 的顺序获取锁。 非公平锁：线程不按照申请锁的顺序来获取锁；一上来就尝试占有锁，如果占有失败，则按照公平锁的方式等待。 通俗来讲，公平锁就相当于现实中的排队，先来后到；非公平锁就是无秩序，谁抢到是谁的； 1.2优缺点 公平锁 优点：线程按照顺序获取锁，不会出现饿死现象（注：饿死现象是指一个线程的CPU执行时间都被其他线程占用，导致得不到CPU执行）。 缺
Java多线程与高并发琐事
weixin_42002747的博客
08-01 149
多线程 进程 进程同步机制 共享内存 信号量 管道 消息队列 套接字 进程的状态和转换 运行、就绪、等待 守护进程 守护进程就是在后台运行,不与任何终端关联的进程, 通常情况下守护进程在系统启动时就在运行, 它们以root用户或者其他特殊用户(apache和 postfix)运行,并能处理一些系统级的任务. 孤儿进程 如果父进程先退出,子进程还没退出那么子进程将被 托孤给init进程 僵尸进程 一个进程已经终止了,但是其父进程还没有获取其状态 如何避免 在父进程
java 中的锁 -- 偏向锁、轻量级锁、自旋锁、重量级锁
热门推荐
zqz_zqz的博客
04-19 14万+
之前做过一个测试，详情见这篇文章《多线程 +1操作的几种实现方式，及效率对比》，当时对这个测试结果很疑惑，反复执行过多次，发现结果是一样的: 1. 单线程下synchronized效率最高（当时感觉它的效率应该是最差才对）； 2. AtomicInteger效率最不稳定，不同并发情况下表现不一样：短时间低并发下，效率比synchronized高，有时甚至比LongAdder还高出一点，但是...
JavaSE01：Java概述
qq_1091994038的博客
07-17 2157
第一章 开发简单的Java应用程序一、Java简介1、Java历史2、Java特点3、Java语言运行机制：跨平台4、Java程序开发和运行的步骤二、Java环境搭建1、JDK、JRE、JVM的区别2、安装JDK3、卸载4、配置path5、检查安装6、Windows操作系统常用的DOS命令7、安装notepad++三、第一个Java程序1、Java的代码结构2、注释三种形式3、java 程序的开发步骤四、编写代码时要注意的问题问题1：乱码问题问题2：大小写问题问题3：格式问题(为了好看)问题4：源文件名和类
MLBTrivia:MLB 琐事 Android 应用程序
06-14
4. **数据存储**：可能使用SQLite数据库存储琐事问题和答案，或者使用SharedPreferences进行轻量级的数据持久化。 5. **网络请求**：如果应用包含实时更新的MLB信息，可能使用HttpURLConnection或第三方库如OkHttp...
javaLauncher源码-Doughnut:我第一次正式尝试编程（Java-JDK8.0-）。这是一个基本但完全可自定义的琐事游戏。它记录
05-20
Doughnut是一个基于Java 8.0开发的基本但可高度定制的琐事游戏。通过研究这个项目的源码，我们可以深入理解Java应用的生命周期、事件驱动编程以及游戏逻辑的实现。 首先，让我们了解一下Java Launcher。在Java应用...
基于 Java 机器学习自学笔记 （第60天：过去十日的总结）
bsegebr的博客
05-20 109
注意：本篇为50天后的Java自学笔记扩充，内容不再是基础数据结构内容而是机器学习中的各种经典算法。这部分博客更侧重于笔记以方便自己的理解，自我知识的输出明显减少，若有错误欢迎指正！ 目录 1.尝试作为知识的输出者 2.机器学习的不确定性 3.关于KNN与KMeans的差异 4.关于Leave-one-out的一些思考 5.关于常用的距离公式整理 5.1 欧氏距离 5.2 曼哈顿距离 6.其余高维距离距离 7.测试与训练的分割应当采用随机数组分割 8.要去怀疑 9.“ 错误的代码 ”反而更高的识别率？ 1
spring事务详细讲解-深入浅出
小电玩
09-08 327
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1322
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1307
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
自定义Stater
m0_63624484的博客
09-07 654
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
基于JavaWeb开发的JavaSpringboot+Vue实现前后端分离房屋租赁系统
央顺科技官方博客
09-05 515
2021年处于信息科技高速发展的大背景之下。在今天，缺少手机和电脑几乎已经成为不可能的事情，人们生活中已经难以离开手机和电脑。针对增加的成本管理和操作,各大商家非常有必要建立自己的网上房屋租赁平台系统，这既可以让更多的人体验到网络所带来的方便，也有助于提高房屋的租赁。在经过几十年的高速发展后，互联网已成为最流行、最普及的媒体，每天的信息流量甚至能比得上过去十年。其以便捷的信息交换、快速的沟通速度，悄然地改变着会员的消费方式。
MyBatis面试
Tony_yitao的博客
09-09 413
MyBatis面试
SpringBoot总结
2302_77073236的博客
09-06 192
都做成图了，方便理解和掌握全局关系。
Web安全之文件上传漏洞和案例示范
最新发布
weixin_39996520的博客
09-09 624
在Web应用程序中，文件上传功能广泛应用，特别是在电商交易系统中，用户上传商品图片、订单文件等操作十分常见。然而，文件上传功能若未被妥善处理，将成为攻击者利用的突破口。本文将以电商交易系统为例，深入分析文件上传过程中的常见安全漏洞，提供相应的解决方案。
Maven：Java项目管理和构建的得力助手
在JavaEE项目中，开发者经常需要引入众多开源框架和第三方库的jar包，而这些jar包之间可能存在复杂的依赖关系。在传统的管理方式中，确定兼容的jar包版本、避免冗余和冲突成为了一大挑战。Maven的出现，通过其强大的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

鲨瓜2号

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值