Java高并发学习（五）—— Java锁

最新推荐文章于 2023-08-28 08:15:00 发布
最新推荐文章于 2023-08-28 08:15:00 发布
阅读量1.1k 收藏
点赞数
分类专栏： 高并发学习 文章标签： 并发编程 锁 公平锁与非公平锁 自旋锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44855907/article/details/117856224
版权

Java锁

https://github.com/yangjinwh/interview 第二季脑图

公平锁与非公平锁

理论

公平锁： 就是按照多线程请求锁的顺序来获取锁。FIFO。与生活中的食堂排队打饭一样，遵循先来后到原则。
非公平锁： 是指多个线程获取锁的顺序，并不是按照申请锁的顺序，有可能先申请的线程后得到锁，即允许插队（线程优先级翻转）或者线程饥饿（某个线程一直得不到锁）。

如何创建

通过ReentrantLock类的构造方法指定boolean类型参数的值，true表示公平锁，false表示非公平锁。默认是非公平锁。
在这里插入图片描述

区别

公平锁就是很公平。在 并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个。就占有锁。否则就会加入到等待队列中，以后按照FIFO的规则由JVM调度。

非公平锁比较粗鲁，上来直接就尝试占用锁，如果尝试失败，在采用类似公平锁的那种方式。
另外ReentrantLock之所以默认是非公平锁，是因为非公平锁比公平锁的吞吐量要大。

公平锁和非公平锁在获取锁的实现上差别在于，非公平锁比公平锁 少了一个!hashQueuedPredecessors()，该方法用于判断是否需要排队，导致公平锁和非公平锁有如下差异：

公平锁： 公平锁讲究先来后到，线程在获取锁时，如果这个锁的等待队列中已经有线程在等待，那么当前线程就会进入 等待队列中。
非公平锁： 不管是否有等待队列，都会先尝试获取锁。也就是锁队列的第一个排队 线程在unpark()之后还是需要竞争锁的。

在这里插入图片描述

可重入锁

理论

可重入锁也叫递归锁。指的是同一线程在外层方法获得锁之后，在进入内层方法是会自动获取锁。也就是说，线程可以进入任何一个已经拥有的锁所同步着的代码块，不会因为之前已经获取过还没有释放而阻塞。可以用下面例子来理解这句话：

public synchronized void method1() { method2();}
public synchronized void method2() {}

线程获取了method1的锁之后，由于method2也是该锁所同步的代码块，所以可以直接进入，自动获得该锁。实际上是对该锁的引用计数器加1.

可重入锁的种类

可重入锁可以分为隐式锁和显式锁。隐式锁是 指的synchronized这类由JVM调控加锁和解锁的锁，默认是可重入锁。显式锁是ReentrantLock由调用者自己加解锁的这样一类锁。隐式锁可以理解为汽车的自动挡，是汽车控制好的了。显式锁可以理解为汽车的手动挡，需要自己把控。

原理

package LockTypeDemo;

/**
 * @author Johnny Lin
 * @date 2021/6/13 12:38
 */
public class Lock_SyncDemo {
    private  final  Object objectLock = new Object();

    public void m1(){
        synchronized (objectLock){
            System.out.println("---------synchronized code block -----------");
        }
    }

    public static void main(String[] args) {

    }
}

进入Lock_SyncDemo.class所在目录下后，使用javap -c Lock_SyncDemo.class反编译。

在这里插入图片描述

每一个锁对象拥有一个锁计数器和一个指向持有该锁的线程的指针。
当执行monitorenter时，

  1. 如果目标锁对象的计数器为0，说明该锁对象没有被其他线程所持有。Java虚拟机会将该锁对象的持有线程置为当前线程，并且将其计数器加1.
  2. 如果目标对象的计数器不为0，如果锁对象的持有线程是当前线程，那么Java虚拟机会将其计数器加1。否则需要等待，直至持有线程释放该锁。这也是同一线程可重入同一对象锁所管控的代码块/方法的原因。

当执行monitorexit是，Java虚拟机则需要将锁对象的计数器减1，当计数器为0时，代表锁已经被释放了。

对应到Java代码实现，如下：

 final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            /*可重入的体现
            	如果当前队列中线程是当前线程
            */
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

作用

可重入锁的作用是避免死锁，比如说上面例子。method1调用method2，如果不是可重入锁，那么method2会一直等待着method1释放掉它所占用的锁，而method1却又一直等着method2执行，就会进入死锁。

可重入验证

验证synchronized

在一个synchronized修饰的方法或代码块内部，调用本类的其他synchronized修饰的方法或代码块，是永远可以得到锁的。

package LockTypeDemo;

/**
 * @author Johnny Lin
 * @date 2021/6/12 22:56
 */


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

        Phone phone = new Phone();
        new Thread(() -> {
            phone.senEmail();
        }, "A").start();
        new Thread(() -> {
            phone.senEmail();
        }, "B").start();
    }
}
//资源类
class Phone{

    public synchronized void senEmail(){
        System.out.println(Thread.currentThread().getName() + "\t invoked sendEmail()");
        //调用另一个同步方法
        sendMsg();
    }

    public synchronized void sendMsg(){
        System.out.println(Thread.currentThread().getName()+"\t invoked sendMsg()");
    }
}

执行结果
在这里插入图片描述

这就说明A线程在进入sendEmail()方法时获取了锁，之后调用同一把锁控制的代码块是会自动获得该锁。而B线程只有等待A线程执行结束释放掉锁之后才能尝试获取 锁。

验证Lock

Phone2资源类实现Runnable接口，run方法中调用sendEmail()，在sendEmail()中调用sendMsg()同步方法。

package LockTypeDemo;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author Johnny Lin
 * @date 2021/6/12 23:12
 */
public class ReentrantLockDemo2 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();

        Thread t1 = new Thread(phone,"t1");
        Thread t2 = new Thread(phone,"t2");
        t1.start();
        t2.start();

    }
}

class Phone2 implements Runnable{
    Lock lock = new ReentrantLock();

    public void sendEmail(){

        lock.lock();
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t invoked sendEmail()");
            sendMsg();
        } finally {
            lock.unlock();
            lock.unlock();
        }
    }

    public void sendMsg(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t invoked sendMsg()");
        } finally {
            lock.unlock();
        }

    }

    @Override
    public void run() {
        sendEmail();
    }
}

执行结果：

在这里插入图片描述

如果sendEmail()方法中加锁和解锁都出现 两次会 怎么样？

   public void sendEmail(){

        lock.lock();
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t invoked sendEmail()");
            sendMsg();
        } finally {
            lock.unlock();
            lock.unlock();
        }
    }

执行结果，正常结束。

在这里插入图片描述

如果sendEmail()方法中加锁两次而解锁只出现一次会 怎么样？

    public void sendEmail(){

        lock.lock();
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t invoked sendEmail()");
            sendMsg();
        } finally {
            lock.unlock();
        }
    }

执行结果：

在这里插入图片描述
这很好理解，因为t1线程一直占用着锁没有释放，所以另一个线程t2因为得不到锁自然就会阻塞。与下面sendMsg()加锁两次只解锁一次是相同的。

 public void sendMsg(){
        lock.lock();
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t invoked sendMsg()");
        } finally {
            lock.unlock();
        }
    }

如果加锁一次而解锁了两次会怎么样？

    public void sendEmail(){

        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t invoked sendEmail()");
            sendMsg();
        } finally {
            lock.unlock();
            lock.unlock();
        }
    }

执行结果：

t1	 invoked sendEmail()
t1	 invoked sendMsg()
t2	 invoked sendEmail()
t2	 invoked sendMsg()
Exception in thread "t1" Exception in thread "t2" java.lang.IllegalMonitorStateException

【总结】
所以Lock的加解锁都要成对出现。

在这里插入图片描述

自旋锁（spinlcok）

理论

自旋锁（spinlock）是指尝试获取锁的线程不会立即阻塞而是采用循环的方式去获取锁。
好处是减少线程上下文切换的消耗，并且保证了并发量。
缺点 当不断自选的线程越来越多时，循环等待会不断消耗CPU资源。

在多线程环境下，CPU采取的策略是为每个线程分配时间片并轮转的形式。
上下文切换就是当前任务在执行完CPU时间片切换到另一个任务之前会先保存自己状态，以便下次再切换回这个任务时，可以在 加载这个任务过程就是一次上下文切换。

自己实现自旋锁

package LockTypeDemo;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

/**
 * @author Johnny Lin
 * @date 2021/6/13 0:01
 */
public class SpinLockDemo {

    //对象线程的原子引用
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void myLock(){

        System.out.println(Thread.currentThread().getName() + "\t come in myLock");
        Thread current = Thread.currentThread();
        // 如果当前已经有线程占有了锁 则自旋
        while( !atomicReference.compareAndSet(null, current)){}
        System.out.println(Thread.currentThread().getName() + " get lock");
    }

    public void myUnLock(){
        System.out.println(Thread.currentThread().getName() + "\t come in myUnLock### ");
        Thread current = Thread.currentThread();
        while( !atomicReference.compareAndSet(current, null)){}
        System.out.println(Thread.currentThread().getName() + " release lock");
    }

    public static void main(String[] args) {

        SpinLockDemo sl = new SpinLockDemo();
        new Thread(() -> {
            sl.myLock();
            try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
            sl.myUnLock();
        }, "A").start();

        //main线程休眠1秒钟 保证A线程优于B线程启动
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            sl.myLock();
            sl.myUnLock();
        }, "B").start();

    }
}

执行结果：

在这里插入图片描述

共享锁和排他锁

理论

共享锁： 也叫读锁。是指该锁允许被多个线程持有。读锁就是一种共享锁。
排他锁： 也叫独占锁。 是指该锁一次只能被一个线程所持有。Synchronized和Lock都是排他锁。写锁也是一种独占锁。

对于 读写锁ReentrantReadWriteLock来说。其读锁readLock就是共享锁，允许多个人同时读。但是其写锁writeLock是独占锁，写的时候只能一个人写。

【读写锁的应用场景】

以前我们使用ReentrantLock创建锁的时候，是独占锁，也就是说一次 只能有一个线程持有该锁。但是存在一种读写分离的场景。也就是读取共享资源时向同时进行，而想去写共享资源时，不希望再有其它线程可以对该资源进行读或写。如果还是使用以前独占锁的方案的话，读的并发性会很差。

因此上述场景可以使用读写锁解决。读写锁用于:

读-读 ： 能共存使，用共享锁
写-写 ：不能共存，使用排他锁
读-写 ： 不能共存，使用排他锁

代码

不加锁

package LockTypeDemo;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * @author Johnny Lin
 * @date 2021/6/13 10:19
 *
 * 内部类如果不为static 则成员变量也不能有static
 * Inner classes cannot have static declarations
 */
public class RWNoLock {
    
    //资源类
    static class Data{

         Map<String,String> map = new HashMap<>();
         public void writeData(String k, String v){
            try { TimeUnit.MICROSECONDS.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("【线程"+Thread.currentThread().getName() +"】"+ "\t 正在写");
            map.put(k, v);
            System.out.println("【线程"+Thread.currentThread().getName() +"】"+"\t 写完");
        }

        public void readData(String k){
            try { TimeUnit.MICROSECONDS.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("【线程"+Thread.currentThread().getName() +"】" + " 读 \t "+ map.get(k));
        }
    }

    public static void main(String[] args) {

        Data data = new Data();
        
        /*
            线程操作资源类 
            创建4个写线程
         */
        for (int i = 0; i < 4; i++) {
            // lambda表达式内部必须是final
            final String temp = String.valueOf(i);
            new Thread(() -> {
                data.writeData(temp, temp);
            }, temp ).start();
        }
        
        /*
            线程操作资源类 
            创建4个读线程
         */
        for (int i = 0; i < 4; i++) {
            // lambda表达式内部必须是final
            final String temp = String.valueOf(i);
            new Thread(() -> {
                data.readData(temp);
            }, temp).start();
        }


    }
}

可以看到，写线程还没写完，就被其他线程打断。其他线程就开始 读/写，这就造成了数据的不一致。

在这里插入图片描述

解决方案

由于上述方案是没有加锁的，所以在写线程进行写的时候会被其他线程打断，从而不具备 原子性，这时候就需要使用读写锁来解决了。

创建读写锁

private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

获得写锁

Lock writeLock = readWriteLock.writeLock();

获取读锁

Lock readLock = readWriteLock.readLock();

ReadWriteLock 的读锁readLock是共享锁，允许多个线程同时读。但是其写锁writeLock是独占锁，写的时候只能一个线程进入写。

package LockTypeDemo;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

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

        Data data = new Data();
        /*
            线程操作资源类
            创建4个写线程
         */
        for(int i = 0; i < 4; i ++){

            // lambda表达式内部必须是final
            final int temp = i;
            new Thread(()->{
                data.write(String.valueOf(temp), String.valueOf(temp) );

            }, i + "").start();
        }
         /*
            线程操作资源类
            创建4个读线程
         */
        for(int i = 0; i < 4; i ++){

            // lambda表达式内部必须是final
            final int temp = i;
            new Thread(()->{
                data.read(String.valueOf(temp));

            }, i + "").start();
        }



    }
}

//资源类
class Data{
    //读写锁
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    //注意，此处需要volatile修饰 ，使得map被其他线程可见
    private volatile Map<String,String> map = new HashMap<>();
	  /**
     * 加入写锁之后使得写操作具有原子性
     */
    public void write(String k, String v){
        //获取写锁
        Lock writeLock = readWriteLock.writeLock();
        writeLock.lock();
        try {
            System.out.println("【线程"+Thread.currentThread().getName()+"】 正在写");
            //模拟网络延时  休眠0.1秒
            TimeUnit.MICROSECONDS.sleep(100);
            map.put(k, v);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println("【线程"+Thread.currentThread().getName()+"】 写完毕");
            writeLock.unlock();
        }

    }
    public void read(String k){
        //获取读锁
        Lock readLock = readWriteLock.readLock();
        readLock.lock();
        try {
            System.out.println("【线程"+Thread.currentThread().getName()+"】 正在读");
            //模拟网络延时  休眠0.1秒
            TimeUnit.MICROSECONDS.sleep(100);
            System.out.println("【线程"+Thread.currentThread().getName()+"】 读"+"\t" +map.get(k));
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            readLock.unlock();
        }
    }
}

执行结果：

在这里插入图片描述

写入操作是一个一个线程进行执行的，并且中间不会被打断，而读操作的时候，是4个线程同时进入，然后并发读取的。

JohnnyLin00
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java高并发编程实战1，那些年学过的锁
学Java，找哪吒
09-07 1万+
一文入门Java高并发
SSM实战项目——Java高并发秒杀API，详细流程+学习笔记
12-27
SSM实战项目——Java高并发秒杀API，详细流程+学习笔记
Java并发编程（四）常见锁及优化
folyh
04-01 751
CDN内容分发网络，是集群页面缓存服务器，尽早返回用户需要的数据，加速用户访问速度，也减轻后端服务器的负载压力；并发时使用它方法包装HashMap同步，这属于全局锁，性能低下。可以使用Ngnix提供缓存功能、或者页面缓存服务器Squid。同 #### 1.2 页面静态化技术。
高并发场景加锁方式及存在的问题
努力努力再努力的小笼包
08-28 746
在多线程高并发场景下，为了保证共享资源的正确性，通常会采用加锁的方式。关于加锁以及一些相关的问题，这里根据个人学习了解的做个汇总。
Java高并发编程：线程锁技术
mocas_wang的博客
09-09 614
目录 1 什么是线程锁 2 synchronized 1. 对象锁 2. 修饰对象方法 3. 类锁 4. 对象锁和类锁 5. 卖火车票示例 6. 生产一个消费一个示例 3 Lock 3.1 重入锁 ReentrantLock 3.2 读写锁 4 Condition 示例1 示例2 5 死锁 1 什么是线程锁 实例的全局变量(共享资源)被修改时，会出现线程安全，需要对修改的方法加锁，注意：只要要访问多个线程共享的字段的方法都需要加锁保护。不能前门(方法A)锁上了，后门(方法B
「高并发业务必读」深入剖析 Java 并发包中的锁机制
tian583391571的专栏
04-13 725
Java 中的线程池是一种常用的并发编程工具，可以优化线程创建和销毁过程，提高程序的性能。在创建线程池时，需要使用构造函数传入不同的参数来配置线程池的行为。常用的线程池构造函数的参数如下：corePoolSize: 线程池中核心线程数量，即在池中保持的最小线程数。maximumPoolSize: 线程池中最大线程数量，当任务队列中的任务已满后，新的任务会创建新的线程直到达到该值。keepAliveTime: 非核心线程空闲等待新任务的存活时间。
Java秒杀系统方案优化——高性能高并发实战
04-10
第1章-课程介绍及项目框架搭建 第2章-实现用户登录以及...第5章-页面级高并发秒杀优化(Redis缓存+静态化分离) 第6章-服务级高并发秒杀优化(RabbitMQ+接口优化) 第7章-图形验证码及恶意防刷 第8章-课程总结及重难点回顾
Java全能学习面试手册——Java面试题库.zip
10-01
Java全能学习面试手册——Java面试题库.zip 01 7道消息队列ActiveMQ面试题！.pdf 02 10道Java高级必备的Netty面试题！.pdf 03 10道Java面试必备的设计模式面试题！.pdf 04 10个Java经典的List面试题！.pdf 05 10个...
SSM实战项目——Java高并发秒杀API.zip
08-17
java+项目实战
SSM实战项目-Java高并发秒杀API
最新发布
05-12
SSM实战项目——Java高并发秒杀API 何为秒杀？ 所谓“秒杀”，就是网络卖家发布一些超低价格的商品，所有买家在同一时间网上抢购的一种销售方式。由于商品价格低廉，往往一上架就被抢购一空，有时只用一秒钟。 ...
java并发-锁
weixin_54401017的博客
09-14 447
轻量级锁的使用场景：如果一个对象虽然有多线程访问，但多线程访问的时间是错开的（也就是没有竞争），那么可以使用轻量级锁来优化。轻量级锁对使用者是透明的，即语法仍然是synchronizd假设有两个方法同步块，利用同一个对象加锁。创建锁记录（Lock Record）对象，每个线程的栈帧都会包含一个锁记录的结构，内部可以存储锁定对象的Mark Word让锁记录中的Object reference 指向锁对象，并尝试用cas替换Object的Mark word，将Mark Word的值存入锁记录。
java-高并发-锁专题
mianmianjun的博客
02-23 429
java-高并发-锁专题锁专题有助于提高锁性能的几点建议：Java虚拟机对锁优化所做的努力无锁CAS（Compare And Swap，比较和交换策略）java中的指针:Unsafe类参考自：Java高并发程序设计-葛一鸣 锁专题 高并发下，激烈的锁竞争会导致程序性能的下降。并行计算之所以能提高系统的性能，并不能因为它“少干活”了，而是因为并行计算可以更合理地进行任务调度，充分利用各个CPU资源。合理的并发才能将多核CPU的性能发挥到极致。 有助于提高锁性能的几点建议： 减少锁持有时间 如同100个人只
干货！java项目分布式锁实现高并发
dayong1q的博客
06-29 670
关于java高并发的实现方式 关于并发的实现方式，结合项目中的实际问题 场景描述：一个电商的商城，用户购买商品进行下单，请求下单接口，会产生并发。 解决方式三部曲： 第一步：基于redis缓存，订单号和对应业务标识作为key 缓存，失效时间根据自己业务的场景是否进行使用 第二步：分布式锁，在微服务下保证幂等，这里特别要注意的是锁的加锁需要设置过期时间，释放问题需要按照每个请求进行解锁 具体步骤如下： //每个请求标识clentId通过UUDID生成 String clientId=UUID.randomUU
Java多线程进阶——常见的锁策略
如风暖阳的博客
09-30 894
Java多线程进阶——常见的锁策略
Java并发——锁（）
编程就像打游戏，编出一个项目就打过了一个BOSS
09-26 617
锁
Java 高并发的几种锁优化方案
xmt1139057136的专栏
08-01 834
你知道的越多，不知道的就越多，业余的像一棵小草！你来，我们一起精进！你不来，我和你的竞争对手一起精进！编辑：业余草来源：cnblogs.com/xdecode/p/9393885.htm...
好程序员Java教程之高并发锁的三种实现方法
qq_35970166的博客
02-06 769
　　高并发（High Concurrency）通常是指在同一个时间点，有很多用户同时的访问同一API接口或者URL地址。高并发是随着分布式系统的问世而出现的，是Java工程师必须要掌握的技能之一。接下来就给大家分享讲解一下高并发锁的实现方法。 1、乐观锁 乐观锁使用的场景是：读不会冲突、写会冲突，同时读的频率远大于写。 参考代码： public object get(Object o...
java高并发的处理--锁机制
zhigang1007的博客
12-27 8871
对于我们开发的网站，如果网站的访问量非常大的话，那么我们就需要考虑相关的并发访问问题了。而并发问题是绝大部分的程序员头疼的问题， 但话又说回来了，既然逃避不掉，那我们就坦然面对吧~今天就让我们一起来研究一下常见的并发和同步吧。 为了更好的理解并发和同步，我们需要先明白两个重要的概念:同步和异步    1、同步和异步的区别和联系  　　所谓同步，可以理解为在执行完一个函数或方
java高并发优化_Java高并发之锁优化
weixin_42393526的博客
02-13 113
本文主要讲并行优化的几种方式, 其结构如下:锁优化减少锁的持有时间例如避免给整个方法加锁1 public synchronized voidsyncMethod(){2 othercode1();3 mutextMethod();4 othercode2();5 }改进后1 public voidsyncMethod2(){2 othercode1();3 ...
Java ReentrantLock
08-29
- *2* *3* [Java锁——搞懂ReentrantLock](https://blog.csdn.net/qq_33333654/article/details/122674531)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值