并发编程专题-04共享模型-无锁（乐观锁）

最新推荐文章于 2022-12-08 23:27:19 发布
最新推荐文章于 2022-12-08 23:27:19 发布
阅读量101 收藏
点赞数
文章标签： java 多线程 并发编程 thread future
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yorickjun/article/details/120283185
版权

1. 无锁和有锁解决线程安全问题

1.1 非线程安全实现

在多线程的环境下，对共享资源的访问存在线程安全问题

public class TestLock {
    public static void main(String[] args) {
        Account.demo(new AccountUnsafe(10000));
    }

}

interface Account{
    public void withdraw(Integer amount);

    public Integer getBalance();

    public static void demo(Account account){
        List<Thread> list = new ArrayList<>();
        long start = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            list.add(new Thread(()->{
                account.withdraw(10);
            }));
        }
        list.forEach(Thread::start);
        list.forEach(t->{
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.nanoTime();
        System.out.println(account.getBalance() + " time:" + (end-start));
    }
}

class AccountUnsafe implements Account{

    private Integer balance;

    public AccountUnsafe(Integer balance) {
        this.balance = balance;
    }

    @Override
    public void withdraw(Integer amount) {
        balance -= amount;
    }

    @Override
    public Integer getBalance() {
        return this.balance;
    }

    @Override
    public String toString() {
        return "AccountUnsafe{" +
                "balance=" + balance +
                '}';
    }
}

1.2 有锁保障线程安全

给 Account 对象加锁

public class TestLock {
    public static void main(String[] args) {
        Account.demo(new AccountSafe(10000));
    }

}

interface Account{
    public void withdraw(Integer amount);

    public Integer getBalance();

    public static void demo(Account account){
        List<Thread> list = new ArrayList<>();
        long start = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            list.add(new Thread(()->{
                account.withdraw(10);
            }));
        }
        list.forEach(Thread::start);
        list.forEach(t->{
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.nanoTime();
        System.out.println(account.getBalance() + " time:" + (end-start));
    }
}

class AccountSafe implements Account{

    private Integer balance;

    public AccountSafe(Integer balance) {
        this.balance = balance;
    }

    @Override
    public synchronized void withdraw(Integer amount) {
        balance -= amount;
    }

    @Override
    public synchronized Integer getBalance() {
        return this.balance;
    }

    @Override
    public String toString() {
        return "AccountUnsafe{" +
                "balance=" + balance +
                '}';
    }
}

1.3 无锁保障线程安全

使用JUC工具包下的原子整数类，实现无锁的线程安全保障

public class TestLock {
    public static void main(String[] args) {
        Account.demo(new  AccountSafe(10000));
    }

}

interface Account{
    public void withdraw(Integer amount);

    public Integer getBalance();

    public static void demo(Account account){
        List<Thread> list = new ArrayList<>();
        long start = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            list.add(new Thread(()->{
                account.withdraw(10);
            }));
        }
        list.forEach(Thread::start);
        list.forEach(t->{
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.nanoTime();
        System.out.println(account.getBalance() + " time:" + (end-start));
    }
}

class AccountSafe implements Account{

    private AtomicInteger balance;

    public AccountSafe(Integer balance) {
        this.balance = new AtomicInteger(balance);
    }

    @Override
    public void withdraw(Integer amount) {
        while (true){
            int prev = balance.get();
            int next = prev - amount;
            if (balance.compareAndSet(prev,next)){
                break;
            }
        }
        // 可以简化为下面的方法
        // balance.addAndGet(-1 * amount);
    }

    @Override
    public Integer getBalance() {
        return balance.get();
    }

    @Override
    public String toString() {
        return "AccountUnsafe{" +
                "balance=" + balance +
                '}';
    }
}

2. CAS原理

2.1 cas解决线程安全的方法图

image-20210618102235345.png

2.2 原理细节

  1. volatile

获取共享变量时，为了保证该变量的可见性，需要使用 volatile 修饰。CAS 必须借助 volatile 才能读取到共享变量的最新值来实现比较并交换的效果。

  1. CAS底层实现

CAS 的底层是 lock cmpxchg 指令(X86 架构)，在单核 CPU 和多核 CPU 下都能够保证比较-交换的原子性。在多核状态下，某个核执行到带 lock 的指令时，CPU 会让总线锁住，当这个核把此指令执行完毕，再开启总线。这个过程中不会被线程的调度机制所打断，保证了多个线程对内存操作的准确性，是原子的。

  1. 无锁效率高的原因

无锁情况下，即使重试失败，线程始终在高速运行，没有停歇，而 synchronized 会让线程在没有获得锁的时候，发生上下文切换，进入阻塞。

  1. CAS的特点

结合 CAS 和 volatile 可以实现无锁并发，适用于线程数少、多核 CPU 的场景下。

  • CAS 是基于乐观锁的思想：最乐观的估计，不怕别的线程来修改共享变量，就算改了也没关系
  • synchronized 是基于悲观锁的思想：最悲观的估计，得防着其它线程来修改共享变量
  • CAS 体现的是无锁并发、无阻塞并发
    • 因为没有使用 synchronized，所以线程不会陷入阻塞，这是效率提升的因素之一
    • 但如果竞争激烈，可以想到重试必然频繁发生，反而效率会受影响

3. 原子整数

例如：AtomicInteger，AtomicBoolean，AtomicLong

//API测试
public class TestLock {
    public static void main(String[] args) {
        AtomicInteger i = new AtomicInteger();
        System.out.println(i.get()); //0
        System.out.println(i.getAndIncrement()); //0
        System.out.println(i.incrementAndGet()); //2
        System.out.println(i.getAndDecrement()); //2
        System.out.println(i.decrementAndGet()); //0
        System.out.println(i.getAndAdd(5)); //0
        System.out.println(i.addAndGet(5)); //10
      //getAndUpdate 如果在 lambda 中引用了外部的局部变量，要保证该局部变量是 final 的
        System.out.println(i.getAndUpdate(x->x+5)); //10
        System.out.println(i.updateAndGet(x->x+5)); //20
      //getAndAccumulate 可以通过 参数1 来引用外部的局部变量，但因为其不在 lambda 中因此不必是 final
        System.out.println(i.getAndAccumulate(10,(p,x)->p+x)); //20
        System.out.println(i.accumulateAndGet(10,(p,x)->p+x)); //40
    }
}

4. 原子引用

例如：AtomicReference，AtomicMarkableReference，AtomicStampedReference

4.1 AtomicReference

使用 AtomicReference 实现对大整数的无锁线程安全操作

//模拟银行取款的大整数无锁线程安全操作
public class TestLock {
    public static void main(String[] args) {
        DecimalAccount.demo(new DecimalAccountSafe(new BigDecimal(10000)));
    }
}

interface DecimalAccount{
    public void withdraw(BigDecimal amount);

    public BigDecimal getBalance();

    public static void demo(DecimalAccount account){
        List<Thread> list = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            list.add(new Thread(()->{
                account.withdraw(BigDecimal.TEN);
            }));
        }
        list.forEach(Thread::start);
        list.forEach(t->{
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(account.getBalance());
    }
}

class DecimalAccountSafe implements DecimalAccount{

    AtomicReference<BigDecimal> balance;

    public DecimalAccountSafe(BigDecimal balance) {
        this.balance = new AtomicReference<>(balance);
    }

    @Override
    public void withdraw(BigDecimal amount) {
        while (true){
            BigDecimal prev = balance.get();
            BigDecimal next = prev.subtract(amount);
            if (balance.compareAndSet(prev,next)){
                break;
            }
        }
    }

    @Override
    public BigDecimal getBalance() {
        return balance.get();
    }
}

4.2 ABA问题

  • 问题演示

如果使用普通的 AtomicReference 会出现仅能判定共享变量的值和初始值是否相同，但是不能感知到该值是否在此之前被修改后，又被修改回来初始值的情况

public class TestLock {
    private static AtomicReference<String> ref = new AtomicReference<>("A");

    public static void main(String[] args) throws InterruptedException {
        String prev = ref.get();
        other(); //其他线程修改该值
        TimeUnit.MICROSECONDS.sleep(1000);
        //依旧可以修改成功
        System.out.println("main: " + ref.compareAndSet(prev, "B")); 
    }

    private static void other() throws InterruptedException {
        new Thread(() -> {
            System.out.println("Thread1: " + ref.compareAndSet(ref.get(), "B"));
        }).start();
        TimeUnit.MICROSECONDS.sleep(1000);
        new Thread(() -> {
            System.out.println("Thread2：" + ref.compareAndSet(ref.get(), "A"));
        }).start();
    }
}
  • 使用 AtomicStampedReference 解决 ABA问题

AtomicStampedReference 可以给原子引用加上版本号，追踪原子引用整个的变化过程，可以获得引用变量中途被更改了几次。

public class TestLock {
    private static AtomicStampedReference<String> ref = new AtomicStampedReference<>("A",0);

    public static void main(String[] args) throws InterruptedException {
        String prev = ref.getReference();
        int stamp = ref.getStamp();
        other();
        TimeUnit.MICROSECONDS.sleep(1000);
        System.out.println("main: " + ref.compareAndSet(prev,"B",stamp,1));

    }

    private static void other() throws InterruptedException {
        new Thread(() -> {
            System.out.println("Thread1: " + ref.compareAndSet(ref.getReference(), "B",0,1));
        }).start();
        TimeUnit.MICROSECONDS.sleep(1000);
        new Thread(() -> {
            System.out.println("Thread2：" + ref.compareAndSet(ref.getReference(), "A",1,2));
        }).start();
    }
}
  • 使用 AtomicMarkableReference 解决 ABA问题

AtomicStampedReference 可以给原子引用加上版本号，但是有时候并不关心引用变量更改了几次，只是单纯的关心是否更改过，此时可以使用该类。

public class TestLock {
    private static AtomicMarkableReference<String> ref = new AtomicMarkableReference<>("A",true);

    public static void main(String[] args) throws InterruptedException {
        String prev = ref.getReference();
        other();
        TimeUnit.MICROSECONDS.sleep(1000);
        System.out.println("main: " + ref.compareAndSet(prev,"B",true,false));

    }

    private static void other() throws InterruptedException {
        new Thread(() -> {
            System.out.println("Thread1: " + ref.compareAndSet(ref.getReference(), "B",true,false));
        }).start();
        TimeUnit.MICROSECONDS.sleep(1000);
        new Thread(() -> {
            System.out.println("Thread2：" + ref.compareAndSet(ref.getReference(), "A",false,false));
        }).start();
    }
}

5.原子数组

例如：AtomicIntegerArray，AtomicLongArray，AtomicReferenceArray

//分别使用不安全和安全的数组，来保存累计数和
public class TestLock {
    public static void main(String[] args) {
        //不安全的数组
        demo(
                () -> new int[10],
                array -> array.length,
                (array, index) -> array[index]++,
                array -> System.out.println(Arrays.toString(array))
        );

        //安全的数组
        demo(
                () -> new AtomicIntegerArray(10),
                array -> array.length(),
                (array, index) -> array.getAndIncrement(index),
                array -> System.out.println(array)
        );
    }

    //函数式编程
// supplier 提供者 无中生有 ()->结果
// function 函数 一个参数一个结果 (参数)->结果 , BiFunction (参数1,参数2)->结果
// consumer 消费者 一个参数没结果 (参数)->void, BiConsumer (参数1,参数2)->void
    private static <T> void demo(
            Supplier<T> arraySupplier,
            Function<T, Integer> lengthFun,
            BiConsumer<T, Integer> putConsumer,
            Consumer<T> printConsumer
    ) {
        List<Thread> list = new ArrayList<>();
        T array = arraySupplier.get();
        int len = lengthFun.apply(array);
        for (int i = 0; i < len; i++) {
            list.add(new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    putConsumer.accept(array, j % len);
                }
            }));
        }
        list.forEach(Thread::start);
        list.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        printConsumer.accept(array);
    }
}
  • result
[8239, 8236, 8257, 8248, 8226, 8250, 8262, 8250, 8232, 8246]
[10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000]

6.字段更新器

例如：AtomicReferenceFieldUpdater，AtomicIntegerFieldUpdater，AtomicLongFieldUpdater利用

字段更新器，可以针对对象的某个域(Field)进行原子操作，只能配合 volatile 修饰的字段使用，否则会出现 异常

//更新字段实例
public class TestLock {

    private volatile Integer fieldNumber;

    public static void main(String[] args) {
        AtomicReferenceFieldUpdater fieldUpdater = AtomicReferenceFieldUpdater.newUpdater(TestLock.class,Integer.class,"fieldNumber");
        TestLock testLock = new TestLock();
        fieldUpdater.compareAndSet(testLock,null,10);
        System.out.println(testLock.fieldNumber);
        fieldUpdater.compareAndSet(testLock,10,20);
        System.out.println(testLock.fieldNumber);
        fieldUpdater.compareAndSet(testLock,10,30);
        System.out.println(testLock.fieldNumber);
    }
}
  • result
10
20
20

7.原子累加器

7.1 累加器性能比较

性能提升的原因是在有竞争时，设置多个累加单元，Therad-0 累加 Cell[0]，而 Thread-1 累加 Cell[1]... 最后将结果汇总。这样它们在累加时操作的不同的 Cell 变量，因此减少了 CAS 重试失败，从而提高性能。

public class TestLock {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            demo(()->new AtomicLong(0),adder->adder.getAndIncrement());
        }
        System.out.println("+++++++++++++++++");
        for (int i = 0; i < 5; i++) {
            demo(()->new LongAdder(),adder->adder.increment());
        }
    }

    private static <T>void demo(Supplier<T> adderSupplier,Consumer<T> action){
        List<Thread> list = new ArrayList<>();
        T adder = adderSupplier.get();
        long start = System.nanoTime();
        // 40个线程，每个线程累加 5 万
        for (int i = 0; i < 40; i++) {
            list.add(new Thread(()->{
                for (int j = 0; j < 50000; j++) {
                    action.accept(adder);
                }
            }));
        }
        list.forEach(Thread::start);
        list.forEach(t->{
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.nanoTime();
        System.out.println("time:"+ (end - start)/1000_000 + " ms");
    }
}
  • result
time:115 ms
time:78 ms
time:76 ms
time:75 ms
time:93 ms
+++++++++++++++++
time:26 ms
time:14 ms
time:24 ms
time:18 ms
time:18 ms

7.2 LongAdder原理

8.Unsafe类

Unsafe 对象提供了非常底层的，操作内存、线程的方法，Unsafe 对象不能直接调用，只能通过反射获得

//使用Unsafe完成CAS操作
public class TestLock {
    public static void main(String[] args) throws NoSuchFieldException {
        Unsafe unsafe = UnsafeAccessor.getUnsafe();
        // 获得成员变量
        Field id = Student.class.getDeclaredField("id");
        Field name = Student.class.getDeclaredField("name");
        // 获得成员变量的偏移量
        long idOffset = unsafe.objectFieldOffset(id);
        long nameOffset = unsafe.objectFieldOffset(name);
        Student student = new Student();
        // 使用 cas 方法替换成员变量的值
        unsafe.compareAndSwapInt(student,idOffset,0,10);
        unsafe.compareAndSwapObject(student,nameOffset,null,"yorick");
        System.out.println(student);
    }
}

@Data
class Student{
    volatile int id;
    volatile String name;
}

class UnsafeAccessor{
    private static Unsafe unsafe;

    static {
        try {
            Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
            theUnsafe.setAccessible(true);
            unsafe = (Unsafe) theUnsafe.get(null);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public static Unsafe getUnsafe() {
        return unsafe;
    }
}
攻城老湿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
乐观锁和无锁
m0_50654102的博客
03-13 816
Lock 是基于 AQS（AbstractQueuedSynchronizer）实现的，AQS 是用来构建 Lock 或其他同步组件的基础，它使用了一个 int 成员变量来表示state（同步状态），通过内置的 FIFO 队列，来完成资源获取线程的排队。 synchronized的方式加锁，会让线程在 BLOCKED 状态和 RUNNABLE 状态之间切换，在操作系统上，就会造成用户态和内核态的频繁切换，效率就比较低。 与 synchronized 的实现方式不同，AQS中很多数据结构的变化，都是依赖 CA
无锁（乐观锁）
weixin_43607641的博客
04-18 289
笔记传送地址： http://note.youdao.com/noteshare?id=c8468057be36cc1876e8317e405e6c4e&sub=C2F5EEFFCCD7455DA2CCA9CC1309AAF3
无锁-乐观锁
qq_45464560的博客
05-11 164
目录问题提出无锁-实现线程安全 问题提出 有如下需求，保证account.withdraw取款方法的线程安全 import java.util.ArrayList; import java.util.List; class TestAccount{ public static void main(String[] args) { Account account = new AccountUnsafe(10000); Account.demo(account);
Java并发编程——无锁(乐观锁)的方式实现并发
qq_40438165的博客
04-21 724
1、CAS \quad使用CAS(compare and swap)来实现无锁时线程安全，因为CAS操作底层是原子的。其实CAS底层是lock cmpxchg指令，在单核和多核CPU下都能够保证比较-交换的原子性。CAS操作需要volatile的支持，需要保证变量的可见性，因此可以用AtomicInteger代替int，其内部使用了volatile修饰。 \quadCAS效率比synchronized效率高，原因？无锁情况下，即使重试失败，线程始终在高速运行，没有停歇，而 synchronized 会让线程
Java并发编程 之 乐观锁和悲观锁
没有进步就是退步
10-31 1608
悲观锁可以把悲观锁想成一个很小心的人，无论做什么操作之前，都要去加个锁，这样别人想拿这个数据就会block直到它拿到锁。但是在效率方面，处理加锁的机制会产生额外的开销，还有增加产生死锁的机会。另外如果只有只读事物，这个锁是没必要的。 传统的关系型数据库里边就用到了很多这种锁机制，比如读锁，写锁等，都是在做操作之前先上锁。悲观锁的实现在java中，synchronized就是一种悲观锁的实现。这个很
Java 并发编程实战.pdf
05-28
在并发控制方面，《Java并发编程实战》可能会探讨不同类型的锁，如互斥锁（Mutex）、读写锁（ReadWriteLock）、乐观锁和悲观锁等，以及它们的应用场景和性能影响。作者可能会使用实例代码来演示如何在实际应用中使用...
Java 高并发四：无锁详细介绍
09-01
CAS操作是无锁编程的基础，它是一个乐观锁策略。在CAS中，有一个比较和交换的过程，包含三个参数：V（要更新的变量）、E（预期值）和N（新值）。当V的值等于E时，才会将V的值更新为N。如果V的值已被其他线程修改，...
Java并发编程全景图.pdf
02-09
Java并发编程是Java语言中最为复杂且重要的部分之一，它涉及了多线程编程、内存模型、同步机制等多个领域。为了深入理解Java并发编程，有必要了解其核心技术点和相关实现原理，以下将详细介绍文件中提及的关键知识点...
并发编程面试题（2020最新版）
05-26
在并发理论中，Java内存模型定义了共享变量的访问规则，以支持Java的并发编程。Java中的垃圾回收机制用于自动释放不再使用的对象所占用的内存资源。finalize()方法是Object类的一个方法，当对象不再被引用时，垃圾...
Java并发编程实践(英文非扫描版-带书签目录)
01-18
10. Java并发编程的未来方向：探讨了并发编程的未来趋势，包括异步编程模型、函数式编程在并发编程中的应用等。 总之，《Java并发编程实践》不仅提供了关于并发编程的全面介绍，还结合了大量案例和最佳实践，是Java...
并发编程JUC深度学习(七）无锁（乐观锁）
左灯右行的爱情
08-02 269
乐观锁
高并发编程之AtomicReference原子类讲解
最新发布
weixin_45080272的博客
12-08 1631
高并发编程之Atomic原子类讲解
使用AtomicReference自己实现锁
weixin_40300139的博客
04-23 184
主题思想：利用AtomicReference自带的CAS机制，实现类似于ReentrantLock的锁，当前线程进入时，CAS验证是否有其他线程持有锁，为null则让当前线程持有，不为null，线程自旋。解锁同理将持有线程置为NULL即可。 package com.zcy.controller; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomi
通过AtomicReference实现一个锁类(CAS原理)
02-10 247
1.AtomicReference了解 AtomicReference类提供了一个可以原子读写的对象引用变量。 原子意味着尝试更改相同AtomicReference的多个线程（例如，使用比较和交换操作）不会使AtomicReference最终达到不一致的状态。 AtomicReference甚至有一个先进的compareAndSet（）方法，它可以将引用与预期值（引用）进行比较，如果它们相等，则在AtomicReference对象内设置一个新的引用。 2. 通过AtomicReference实现..
并发编程——共享模型之无锁
一只奋斗的程序羊博客
08-07 568
目录 一、并发编程无锁案例 无锁高效率 二、CAS（compareAndSet） CAS和volatile的关系 CAS的特点 三、ABA问题 解决 四、CAS操作的原子类 原子整数 原子引用 原子数组 字段更新器 原子累加器 五、原子累加器 原子累加器与原子整数的性能比较 六、原子累加器LongAdder原理 LongAdder类有几个关键域 CAS锁 伪共享 LongAdder源码 七、Unsafe Unsafe的CAS操作实现 一、并发编...
JAVA多线程学习------CAS和乐观锁
qq_43719634的博客
10-22 92
1.CAS操作 引入：利用CAS改写取款程序。 class Accoumt{ private AtomicInteger balance; public int getBalance() { return balance.get(); } public Accoumt(int balance){ this.balance = new AtomicInteger(balance); } public void wit
Java中的乐观锁——无锁策略
weixin_34122604的博客
11-25 700
题主在阅读《实战Java高并发程序设计》一书时，了解到了Java无锁的相关概念，在此记录下来以加深对其的理解，Java中的锁分为两种即为悲观锁和乐观锁，那么何为悲观锁和乐观锁呢？ 点击查看原文 乐观锁与悲观锁 悲观锁是我们代码经常用到的，比如说Java中的synchronized和ReentrantLock等独占锁就是悲观锁思想的实现，它总是假设别的线程在拿数据的时候都会修改数据，所以在每次拿到数...
高并发编程之高并发场景：秒杀（无锁、排他锁、乐观锁、redis缓存的逐步演变）
热门推荐
叶落自飘零的博客
10-19 5万+
环境： jdk1.8；spring boot2.0.2；Maven3.3 摘要说明： 在实际开发过程中往往会出现许多高并发场场景，秒杀，强红包，抢优惠卷等； 其中： 秒杀场景的特点就是单位时间涌入用户量极大，商品数少，且要保证不可超量销售； 秒杀产品的本质就是减库存； 秒杀场景常用的解决方案有限流、削峰、拓展等 本篇以秒杀场景为依据来主要从代码开发的角度阐述从无锁——》排他锁——》...
C++并发编程实战：掌握TR2标准与高级同步技术
7. **设计并发数据结构II：无锁并发数据结构**：探索不依赖于锁的并发数据结构，如CAS（Compare-and-Swap）和乐观锁等高级技术。 8. **设计并发代码**：提供编写并发代码的策略和模式，如何处理异常、错误和死锁等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

攻城老湿

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

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

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

打赏作者

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

抵扣说明：

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

余额充值