Java_阻塞队列接口和实现类

最新推荐文章于 2022-10-30 18:23:19 发布
最新推荐文章于 2022-10-30 18:23:19 发布
阅读量408 收藏 4
点赞数
分类专栏： Java 文章标签： Java queue 多线程并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44345917/article/details/102752125
版权

Java_阻塞队列BlockingQueue接口和实现类

（一）什么是BlockingQueue？

collection接口------>Queue接口------>BlockingQueue接口----->7个实现类

在这里插入图片描述

  • 当阻塞队列是空时，从队列中获取元素的操作将会被阻塞
  • 当阻塞队列是满时，往队列里添加元素的操作将会被阻塞

想想 蛋糕店摆出十个蛋糕 卖出了才继续做 不浪费

（二）7个实现类

collection接口------>Queue接口------>BlockingQueue接口----->7个实现类

ArrayBlockingQueue【*】：由数组结构组成的有界阻塞队列。
LinkedBlockingQueue【*】：由链表结构组成的有界（但默认大小值为Interger.MAX_VALUE）阻塞队列。
PriorityBlockingQueue：支持优先级排序的无界阻塞队列。
DelayQueue：使用优先级队列实现的延迟无界阻塞队列。
SynchronousQueue【*】：不存储元素的阻塞队列，也即单个元素的队列。就好比高定，定一个做一个
LinkedTransferQueue：由链表结构组成的无界阻塞队列。
LinkedBlockingDeque：由链表结构组成的双向阻塞队列。

（三）BlockingQueue核心方法

3.1 理论

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SvucoOT4-1572022147843)(C:\Users\LENOVO\Desktop\SGG大数据笔记\noteimgs\BlockingQueue核心方法.PNG)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8ZR0stgt-1572022147844)(C:\Users\LENOVO\Desktop\SGG大数据笔记\noteimgs\BlockingQueue核心方法2.PNG)]

3.2 代码演示

用ArrayBlockingQueue实现类举例演示
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * collection接口------>Queue接口------>BlockingQueue接口----->7个实现类
 * ArrayBlockingQueue：由**数组结构**组成的**有界阻塞队列**。
 * LinkedBlockingQueue：由**链表结构**组成的**有界**（但默认大小值为Interger.MAX_VALUE）**阻塞队列**。
 * SynchronousQueue：**不存储元素的阻塞队列**，也即单个元素的队列。就好比高定，定一个做一个。
 *
 * BlockingQueue常用的四组方法
 *
 */

public class BlockingQueueDemo {
    public static void main(String[] args) throws InterruptedException {
//        method1();
//        method2();
//        method3();
        method4();


    }

    /**
     * method1
     * 抛出异常
     * add
     * remove
     * element
     */
    public static void method1(){
        //List list = new ArrayList();
        ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);

        //add
        System.out.println(blockingQueue.add("a"));//true
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));

//        System.out.println(blockingQueue.add("x")); //抛异常

        //element 审查有没有元素和队首
        System.out.println(blockingQueue.element()); //a

        //remove
        System.out.println(blockingQueue.remove());//a
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove()); //抛异常

    }

    /**
     *  method2
     * 特殊值
     * add
     * remove
     * element
     */
    public static void method2(){
        //List list = new ArrayList();
        ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);

        //offer
        System.out.println(blockingQueue.offer("a"));//true
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));

        System.out.println(blockingQueue.offer("x")); //false

        //offer 审查有没有元素和队首
        System.out.println(blockingQueue.peek()); //a

        //poll
        System.out.println(blockingQueue.poll()); //a
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll()); //null
    }


    /**
     *  method3
     * 阻塞
     * put
     * take
     */
    public static void method3() throws InterruptedException {
        //List list = new ArrayList();
        ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);

        //put
        blockingQueue.put("a");//无返回
        blockingQueue.put("b");
        blockingQueue.put("c"); //这步后就会阻塞，直到取走

//        blockingQueue.put("x"); //
        System.out.println("--------");

        //take
        blockingQueue.take();
        blockingQueue.take();
        blockingQueue.take(); //3生产 3消费 程序会正常退出
//        blockingQueue.take(); //3生产 4消费 程序会阻塞 等待生产
    }


    /**
     *  method4
     * 超时
     * offer(e,time,unit)
     * poll(time,unit)
     */
    public static void method4() throws InterruptedException {
        //List list = new ArrayList();
        ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);

        //offer(e,time,unit)
        System.out.println(blockingQueue.offer("a",2L, TimeUnit.SECONDS));//true
        System.out.println(blockingQueue.offer("b",2L, TimeUnit.SECONDS));
        System.out.println(blockingQueue.offer("c",2L, TimeUnit.SECONDS));

        System.out.println(blockingQueue.offer("x",2L,TimeUnit.SECONDS)); //false

        //poll(time,unit)
        System.out.println(blockingQueue.poll(2L,TimeUnit.SECONDS)); //a
        System.out.println(blockingQueue.poll(2L,TimeUnit.SECONDS));
        System.out.println(blockingQueue.poll(2L,TimeUnit.SECONDS));
        System.out.println(blockingQueue.poll(2L,TimeUnit.SECONDS)); //null

    }

}

/*
-----method1
true
true
true
Exception in thread "main" java.lang.IllegalStateException: Queue full


-----method2
true
true
true
false
a
a
b
c
null


----method4
true
true
true
false
a
b
c
null

 */

（四）阻塞队列SynchronousQueue实现类演示

没有容量 你不消费 我不生产
每一个put操作必须要等待一个take操作，否则不能继续添加元素，反之亦然

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/**
 * 队列之同步SynchronousQueue队列
 */
public class SynchronousQueueDemo {
    public static void main(String[] args) {

        BlockingQueue<String> blockingQueue = new SynchronousQueue<>();

        //put
        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"\tput 1");
                blockingQueue.put("1");

                System.out.println(Thread.currentThread().getName()+"\tput 2");
                blockingQueue.put("2");

                System.out.println(Thread.currentThread().getName()+"\tput 3");
                blockingQueue.put("3");

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"AAA").start();

        //take
        new Thread(()->{
            try {
                //暂停一会儿线程
                TimeUnit.SECONDS.sleep(5);
                System.out.println(Thread.currentThread().getName()+"\t"+blockingQueue.take());
                TimeUnit.SECONDS.sleep(5);
                System.out.println(Thread.currentThread().getName()+"\t"+blockingQueue.take());
                TimeUnit.SECONDS.sleep(5);
                System.out.println(Thread.currentThread().getName()+"\t"+blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"BBB").start();

    }

}

/*
AAA	put 1
BBB	1
AAA	put 2
BBB	2
AAA	put 3
BBB	3
 */

（五）用在哪里

5.1 生产者消费者模式

5.1.1 传统版
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 传统版的生产者消费者模式，多线程消费，生产一个消费一个
 *
 * JUC中
 * sync----lock
 * wait----await
 * notify----signal
 *
 * 多线程的判断必须要用while
 *
 */

/**
 * 资源类
 *
 * Condition它更强大的地方在于：
 * 能够更加精细的控制多线程的休眠与唤醒。
 * 对于同一个锁，我们可以创建多个Condition，
 * 在不同的情况下使用不同的Condition
 *
 */
class ShareData{
    private int number = 0;
    private Lock lock =new ReentrantLock();
    private Condition condition = lock.newCondition();

    //增加方法
    public void increment() throws Exception{
        lock.lock();   //ctrl+alt+T  try-catch快捷键
        try {
            //1、判断
            while (number != 0){
                //等待 不能生产
                condition.await();
            }
            //2、干活
            number++;
            System.out.println(Thread.currentThread().getName()+"\t"+number);

            //通知唤醒
            condition.signalAll();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //减少方法
    public void decrement() throws Exception{
        lock.lock();   //ctrl+alt+T  try-catch快捷键
        try {
            //1、判断
            while (number == 0){
                //等待 不能生产
                condition.await();
            }
            //2、干活
            number--;
            System.out.println(Thread.currentThread().getName()+"\t"+number);

            //通知唤醒
            condition.signalAll();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

/**
 * 一个初始值为零的变量，两个线程交替操作，一个加一，一个减一
 * 1    线程      操作（方法）      资源类
 * 2    判断      干活      通知唤醒
 * 3    防止虚假唤醒机制
 */
public class prodConsumer_TraditionDemo {
    public static void main(String[] args) {

        ShareData shareData = new ShareData();

        for (int i=0;i<5;i++) {
            new Thread(() -> {
                try {
                    shareData.increment(); //调用增加方法
                } catch (Exception e) {
                    e.printStackTrace();
                }
            },"AA").start();
        }


        for (int i=0;i<5;i++) {
            new Thread(() -> {
                try {
                    shareData.decrement();  //调用减少方法
                } catch (Exception e) {
                    e.printStackTrace();
                }
            },"BB").start();
        }

    }
}


/*
AA	1
BB	0
AA	1
BB	0
AA	1
BB	0
AA	1
BB	0
AA	1
BB	0
 */
5.1.2 阻塞队列版
【sychronized和lock的区别】
/**
 * sychronized和lock的区别
 *
 * 1 原始构成
 * sync关键字属于JVM层面，
 *      monitorenter（底层是通过moniotr对象来完成，其实wait、notify
 *      等方法也依赖于monitor对象，只有在同步块或方法中才能调用wait/
 *      notify等方法）
 *      monitorexit
 * lcok是具体类（java.util.concurrent.locks.Lock）是api层面的锁
 *
 * 2 使用方法
 * sync不需要手动去释放锁，当sync代码执行完成后系统会自动让线程释放
 *      对锁的占用
 * ReentrantLock则需要用户手动释放锁，如果没有手动释放锁，可能会出现
 *              死锁现象。需要lock()和unlock()方法配合try/finally语句块来完成。
 *
 * 3 等待可否中断
 * sync不可中断，除非抛出异常或者正常运行完成
 * ReentrantLock 可中断，1.设置超时方法
 *                         tryLock(long timeout,TimeUnit unit)
 *                      2. lcokInterruptibly()放代码块中，调用
 *                         interrupt()方法可中断
 *
 * 4 加锁是否公平
 * sync非公平锁
 * ReentrantLock两者都可以，默认非公平锁，构造方法中可以传入boolean值，
 *              true为公平锁，false为非公平锁
 *
 * 5 锁绑定多个条件Condition
 * sync没有 要么随机唤醒一个线程，要么全部唤醒线程
 * ReentrantLock用来实现分组唤醒的线程们，可以精确唤醒
 *
 *
 * 精确唤醒的例子
 * 题目：
 *  多线程之间按顺序调用，实现A->B->C三个线程启动，要求如下
 *  AA打印3次，BB打印4次，CC打印5次
 *  紧接着
 *  AA打印3次，BB打印4次，CC打印5次
 *  ...
 *  来五轮
 *
 */

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

/**
 * 资源类
 * 1通知2  2通知3  3通知1
 */
class ShareResource{
    private int number = 1; //A:1 B:2 C:3
    private Lock lock = new ReentrantLock();
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();

    public void print3(){
        lock.lock();
        try {
            //1 判断
            while (number !=1){
                c1.await();  //private Condition c1 = lock.newCondition();
            }
            //2 干活
            for (int i = 1; i <= 3; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //3 通知
            number = 2; //1通知2  2通知3  3通知1
            c2.signal(); //只通知2 !!!!
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void print4(){
        lock.lock();
        try {
            //1 判断
            while (number !=2){
                c2.await();  //private Condition c1 = lock.newCondition();
            }
            //2 干活
            for (int i = 1; i <= 4; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //3 通知
            number = 3; //2通知3
            c3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void print5(){
        lock.lock();
        try {
            //1 判断
            while (number !=3){
                c3.await();  //private Condition c1 = lock.newCondition();
            }
            //2 干活
            for (int i = 1; i <= 5; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //3 通知
            number = 1; //3通知1
            c1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

public class SyncAndReentrantLockDemo {
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();

        new Thread(()->{
            for (int i = 0; i < 5 ; i++) {
                shareResource.print3();
            }
        },"AAA").start();
        new Thread(()->{
            for (int i = 0; i < 5 ; i++) {
                shareResource.print4();
            }
        },"BBB").start();
        new Thread(()->{
            for (int i = 0; i < 5 ; i++) {
                shareResource.print5();
            }
        },"CCC").start();
    }

}


/*
AAA	1
AAA	2
AAA	3
BBB	1
BBB	2
BBB	3
BBB	4
CCC	1
CCC	2
CCC	3
CCC	4
CCC	5
AAA	1
AAA	2
AAA	3
BBB	1
BBB	2
BBB	3
BBB	4
CCC	1
CCC	2
CCC	3
CCC	4
CCC	5
AAA	1
AAA	2
AAA	3
BBB	1
BBB	2
BBB	3
BBB	4
CCC	1
CCC	2
CCC	3
CCC	4
CCC	5
AAA	1
AAA	2
AAA	3
BBB	1
BBB	2
BBB	3
BBB	4
CCC	1
CCC	2
CCC	3
CCC	4
CCC	5
AAA	1
AAA	2
AAA	3
BBB	1
BBB	2
BBB	3
BBB	4
CCC	1
CCC	2
CCC	3
CCC	4
CCC	5


 */

5.2 线程池

后续补充

5.3 消息中间件

大数据小阿姨
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现简单的阻塞队列2种方式
06-10
Java实现简单的阻塞队列2种方式，1使用wait()，notify();2使用countdownlatch实现
java阻塞队列实现原理及实例解析
08-25
Java阻塞队列实现原理及实例解析 Java阻塞队列是一种特殊的队列，它能够在队列为空或满时阻塞线程，使得线程之间能够更好地协作和通信。阻塞队列的实现原理是基于锁机制和条件变量机制的，通过wait和notify方法来...
JAVA之阻塞队列接口结构和实现类
群鸟飞扬
04-26 320
阻塞队列 首先它是一个队列，
实现阻塞队列
dghehe的博客
09-24 1061
这就是线程安全的阻塞队列。所以我们当队列满的时候就让该线程调用wait方法阻塞，当取出完元素的时候就把该线程调用notify唤醒。3、多设置一个成员变量size，size==elem.length时就是满 ，size==0时为空。同样的当队列空时调用wait阻塞，当添加完元素的时候就把该线程调用notify唤醒。环形队列实现的核心就在于，如何解决head==tail时到底是满了还是空的问题。阻塞队列的特点，阻塞队列首先我们就要使用数组实现一个环形队列。当队列为满时，向队列中添加元素的操作会被阻塞。
基于LinkedBlockingQueue实现的内存队列
Seven71111的博客
10-10 854
目录 描述 应用场景:redis的双写数据一致性 基于LinkedBlockingQueue实现的内存队列demo 配置线程池 项目启动即开始等待消费队列中的消息（模拟生产消息） 描述 如果在消息处理的时候特别费时间，这个时候如果有新的消息来了，就只能处于阻塞状态，造成用户等待。这个时候在项目中引入队列是十分有必要的。当我们接受到消息后，先把消息放到队列中，然后再用新的线程进行处理，这个时候就不会有消息的阻塞了。 首先，我们来看看基于内存的队列。在Java的并发包中已经提供了Blocking
【Java多线程】阻塞队列（BlockingQueue接口）
Awt_FuDongLai的博客
08-20 301
1 阻塞队列的好处 定义：阻塞队列首先是一个队列。当阻塞队列为空时，从队列中获取元素的操作将会被阻塞；当阻塞队列为满时，往队列里添加元素的操作将会被阻塞。 阻塞：在多线程领域，阻塞就是在某些情况下会挂起线程；一旦条件满足，被挂起的线程又会自动被唤醒。 BlockingQueue：使用的好处是不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，都交给它去处理，不需要手动管理。 2 不得不阻塞，如何管理 2.1 ArrayBlockingQueue 由数组结构组成的有界阻塞队列。 2.2 Link
Java wait和notifyAll实现简单的阻塞队列
08-25
Java wait和notifyAll实现简单的阻塞队列 在 Java 中，wait 和 notifyAll 是两个非常重要的方法，它们都是在 Object 类中声明的，用于实现线程之间的通信和同步。wait 方法会使调用线程进入等待状态，并释放所持有...
详解Java阻塞队列(BlockingQueue)的实现原理
08-30
"详解Java阻塞队列(BlockingQueue)的实现原理" Java阻塞队列（BlockingQueue）是Java.util.concurrent包下重要的数据结构，提供了线程安全的队列访问方式。BlockingQueue的实现原理主要是基于四组不同的方法用于...
day19_阻塞队列、线程池、File类、递归.pdf
11-02
【正文】 本文主要讲解了Java中的阻塞队列、线程池以及File类的相关知识，并...以上内容涵盖了阻塞队列、线程池、File类和递归的基础知识，它们都是Java编程中不可或缺的部分，对于理解和编写高效的并发程序至关重要。
java利用delayedQueue实现本地的延迟队列
08-30
DelayedQueue 是 Java 中的一种特殊的阻塞队列，它用于存放实现了 Delayed 接口的对象。这种队列是有序的，即队头对象的延迟到期时间最长。 DelayedQueue 能够满足我们在业务中的一些需求，如淘宝订单业务中，下单...
java集合工具类，并发集合类，阻塞容器类接口
mark's technic world
04-23 405
1java集合工具类接口 2并发集合类接口 3阻塞容器类接口 1java集合工具类接口 1.1Collection 说明： 1.2List 说明： 1.3Set 说明： 1.4Map 说明： 1.5queue 说明： 1.6Deque 说明： 1.
《 Java并发编程从入门到精通》 多线程之间交互：线程阀
GY的的专栏
11-06 966
5.1 线程安全的阻塞队列BlockingQueue (1)先理解一下Queue、Deque、BlockingQueue的概念： Queue(队列) ：用于保存一组元素，不过在存取元素的时候必须遵循先进先出原则。队列是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空
Java 容器源码分析之ArrayBlockingQueue和LinkedBlockingQueue
aikuangchou2298的博客
04-08 141
Java中的阻塞队列接口BlockingQueue继承自Queue接口。 BlockingQueue接口提供了3个添加元素方法。 add：添加元素到队列里，添加成功返回true，由于容量满了添加失败会抛出IllegalStateException异常 offer：添加元素到队列里，添加成功返回true，添加失败返回false put：添加元素到队列里，如果容量满了会阻塞直到容...
实现一个简单的阻塞队列
weixin_44718747的博客
07-04 102
package ThreadTest.myBlockQueue; import java.util.ArrayList; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /* * 利用Loc
java 数据结构之 并发队列 之Queue 接口实现类 ConcurrentLinkedDeque 源码解析
xiaoliuliu2050的专栏
03-07 360
private void linkFirst(E e) { checkNotNull(e); final Node&lt;E&gt; newNode = new Node&lt;E&gt;(e); restartFromHead: for (;;) for (Node&lt;E&gt; h = head, p = h, q;;) { ...
09.阻塞队列BlockingQueue接口
qq_27552845的博客
08-27 243
9.阻塞队列BlockingQueue接口 对于阻塞队列： 写入的时候如果队列满了，就必须阻塞等待消费。 读取的时候，如果队列是空的，就必须等待生产。 BlockingQueue其实和ArrayList是同级的，其最初都继承自Collection 9.1ArrayBlockingQueue的四种操作 方式 抛出异常 有返回值，不抛出异常 阻塞 等待 超时等待 添加 add offer() put() offer(,) 移除 remove poll() take() poll(,)
什么？面试官让我用ArrayList实现一个阻塞队列？
dhaibo1986的专栏
09-01 430
在准备开始详细分析java多线程源码时，发现了这样一个问题，也就是说，在面试的时候经常要求，手写阻塞队列，或者手写一个程序，交替打印1-10000。于是，看到这里经不住动手一试。 基础知识 实际上，要实现一个BlockQueue，实际上就是自己写一个简单的生产者、消费者模型的代码。需要我们实现一个Queue，做为临界区，之后，当临界区不足的时候可以添加元素，当临界区达到阈值的时候则生产者线程等待。同理，对于消费者线程，那么当临界区有元素的时候就可以消费，没用元素的时候就要停止消费。那么我们需要用到 sync
接口阻塞问题解决
litthh
10-11 2627
【问题一：gethostbyname阻塞卡死】复现条件多为域名解析过程中遇到与DNS服务器断开的情况(如路由器重启)。 【解决方法】首先使用gethostbyname_r函数保证线程安全；再通过修改DNS的配置文件/etc/resolv.conf来设置超时时间解决阻塞问题。 【问题二：SSL_connect卡死】复现条件不明确，推测网络复杂时易出现。网查该函数默认有超时时间，但实测会永久阻塞，怀疑与使用的wolfssl库配置参数有关。 【解决方法】首先将socket改为非阻塞：fcntl(hHandle,
Java阻塞队列的模拟实现
m0_58154870的博客
10-30 364
Java中是有阻塞队列的实现的. BlockingQueue 是阻塞队列的接口 对于接口也有多种类型不同的实现 LinkedBlockingQueue ArrayBlockingQueue
java 实现 有界阻塞队列的定时任务 ScheduledThreadPoolExecutor
最新发布
11-22
下面是Java实现有界阻塞队列的定时任务ScheduledThreadPoolExecutor的方法和步骤： 1. 首先，需要导入java.util.concurrent.ScheduledThreadPoolExecutor类和java.util.concurrent.TimeUnit类。 2. 创建...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值