java多线程之阻塞队列--BlockingQueue

最新推荐文章于 2023-03-29 19:17:34 发布
最新推荐文章于 2023-03-29 19:17:34 发布
阅读量251 收藏
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiushancunMonkeyKing/article/details/80729744
版权

BlockingQueue阻塞队列的一些方法介绍：


BlockingQueue是一个接口，实现类如下


下面将介绍实现类的用法，和一些简单的列子

1).ArrayBlockingQueue：数组阻塞队列

       数组阻塞队列是一个有边界，支出先进先出(FIFO first in first out)的队列，数组的头部元素是在数组中存在时间最长的元素，ArrayBlockingQueue中，生产者和消费者共同使用同一个锁，所有没有做到完全的并行操作，这一点与LinkedBlockingQueue不同，

2).LinkedBlockingQueue : 链表阻塞队列

       LinkedBlockingQueue类似ArrayBlockQueue，是一个链表阻塞队列，但是生产者和消费者使用的是两个锁，所有在存储元素的同时也可以获取元素，LinkedBlockQueue 如果没有初始化大小的时候，当生产者存储元素的速度大于消费者消费元素的速度时，LinkedBlockingQueue会无限增长，在这种情况下，系统内存可能会消耗殆尽。

来看一个列子

package com.queue;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * 链表阻塞队列测试
 * @author Administrator
 *
 */
public class MyLinkedBlockingQueue {
	
	public static void main(String[] args) throws InterruptedException {
		LinkedBlockingQueue<String> abq = new LinkedBlockingQueue<String>(10);
		//三个生产者
		Producer p1 = new Producer(abq);
		Producer p2 = new Producer(abq);
		Producer p3 = new Producer(abq);
		//一个消费者
		Consumer queue1 = new Consumer(abq);
		//生成一个缓存线程池
		ExecutorService pool = Executors.newCachedThreadPool();
		
		pool.execute(p1);
		pool.execute(p2);
		pool.execute(p3);
		pool.execute(queue1);
		
		//当前线程睡眠10秒，等待线程池中的线程执行
		TimeUnit.SECONDS.sleep(10);
		
		//调用方法停止线程
		p1.myStop();
		p2.myStop();
		p3.myStop();
		
		TimeUnit.SECONDS.sleep(20);
		//启动一次顺序关闭，执行以前提交的任务，但不接受新任务
		pool.shutdown();
	}
	
}

/**
 * 消费者
 * @author lijh
 *
 */
class Consumer implements Runnable{
	//注入队列
	private LinkedBlockingQueue<String> abq;
	
	private Boolean flag = true;
	
	public Consumer(LinkedBlockingQueue<String> abq){
		this.abq = abq;
	}
	
	@Override
	public void run() {
		System.out.println("启动消费者线程");
		while(flag){
			try {
				// 获取并移除此队列的头部，在指定的等待时间前等待可用的元素（如果有必要）。
				String date = abq.poll(2, TimeUnit.SECONDS);
				if(date != null){
					System.out.println("消费者得到数据 "+date);
					//休眠一秒
					TimeUnit.SECONDS.sleep(1);
				}else{//没有获取到数据,则退出循环
					flag = false;
					System.out.println("没有可获取的数据");
				}
				
			} catch (InterruptedException e) {
				e.printStackTrace();
				Thread.currentThread().interrupt();
			}
		}
		
	}
	
	
}

/**
 * 生产者
 * @author lijh
 *
 */
class Producer implements Runnable{

	//注入队列
	private LinkedBlockingQueue<String> abq;
	//线程执行标准为
	boolean flag = true;
	
	public Producer(LinkedBlockingQueue<String> abq){
		this.abq = abq;
	}
	
	public void myStop() {
		flag = false;
	}
	
	@Override
	public void run() {
		Random r = new Random();
		System.out.println("启动生产者线程");
		while(flag){
			System.out.println("开始生产数据"+ Thread.currentThread().getName());
			try {
				TimeUnit.SECONDS.sleep(1);
				// 将指定元素插入此队列中，在到达指定的等待时间前等待可用的空间（如果有必要）。
				if(!abq.offer("date "+r.nextInt(), 2, TimeUnit.SECONDS)){
					System.out.println("放入数据失败。。。");
					myStop();
				}else{
					System.out.println("数据生产成功"+ Thread.currentThread().getName());
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
				//如果出现异常，则终止线程
				Thread.currentThread().interrupt();
			}
			
		}
	}
	
}

部分执行结果

        

当队列放满时，再次调用abq.offer()往队列中存放元素，会返回false,然后我们调用mystop()方法终止线程，当队列元素为空时，再次调用abq.poll()方法得到元素，会返回null，我们手动终止线程。上面的列子我们可以吧LinkedBlockingQueue换成ArrayBlockingQueue也是可以执行的。

3).PriorityBlockingQueue优先级阻塞队列

存储在PriorityBlockingQueue队列中的元素必须实现Comparable接口来进行优先级排序，PriorityBlockingQueue是一个无界的队列，所有当生产者速度快于消费者时，会使内存消耗殆尽，需要注意，当队列中没有元素时，获取元素时会产生阻塞，PriorityBlockingQueue的生产者和消费者使用同一把锁，和ArrayBlckingQueue一样


package com.queue;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * 优先级阻塞队列,存储元素时不会阻塞，因为是一个无界队列，获取元素时，当队列为空时，会阻塞
 * @author lijh
 *
 */
public class MyPriorityBlockingQueue {
	
	public static void main(String[] args) throws InterruptedException {
		PriorityBlockingQueue<User> pbq = new PriorityBlockingQueue<User>();
		
		Producer2 p1 = new Producer2(pbq);
		
		Producer2 p2 = new Producer2(pbq);
		
		Consumer2 c1 = new Consumer2(pbq);
		
		ExecutorService pool = Executors.newFixedThreadPool(3);
		pool.execute(p1);
		pool.execute(p2);
		pool.execute(c1);
		
		//main线程睡眠10秒，等待线程池中的线程执行
		TimeUnit.SECONDS.sleep(10);
		
		TimeUnit.SECONDS.sleep(10);
		//启动一次顺序关闭，执行以前提交的任务，但不接受新任务
		pool.shutdown();
		
	}

}

class User implements Comparable<User>{

	//优先级
	private Integer priority;
	//用户名
	private String username;
	
	public User(Integer priority,String username){
		this.priority = priority;
		this.username = username;
	}
	
	//优先级排序方法
	@Override
	public int compareTo(User o) {
		
		return this.priority.compareTo(o.getPriority());
	}

	public Integer getPriority() {
		return priority;
	}

	public void setPriority(Integer priority) {
		this.priority = priority;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}
	
}

/**
 * 生产者
 * @author lijh
 *
 */
class Producer2 implements Runnable{

	boolean flag=true;
	
	private PriorityBlockingQueue<User> pbq;
	
	public Producer2(PriorityBlockingQueue<User> pbq){
		this.pbq = pbq;
	}
	
	@Override
	public void run() {
		Random r = new Random();
		int i=1;
		while(flag){
			pbq.put(new User(r.nextInt(20),"李雷"+i));
			System.out.println("生产数据成功");
			i++;
			if(i>5){//大于5的时候终止,两个生产者线程，一共会产生10个元素
				flag=false;
			}
		}
	}
	
}

/**
 * 消费者
 * @author lijh
 *
 */
class Consumer2 implements Runnable{

	boolean flag = true;
	
	private PriorityBlockingQueue<User> pbq;
	
	public Consumer2(PriorityBlockingQueue<User> pbq){
		this.pbq = pbq;
	}
	
	@Override
	public void run() {
		while(flag){
			try {
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			User user = pbq.poll();
			if(user == null){
				System.out.println("没有元素可以获取");
				flag = false;
			}else{
				System.out.println(user.getUsername()+"的优先级为"+user.getPriority());
			}
		}
	}
	
	
}

4).延时队列DelayQueue

     延时队列是一个支持延时获取元素的使用优先级队列实现的无界队列，优先级需要实现Comparable接口，延时需要实现Delayed接口，而Delayed接口实现了Comparable接口，所以我们只需要实现Delayed接口就可以了。

     延时队列使用场景一般是定时任务和缓存系统设计

package com.queue;

import java.util.Iterator;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * 延时队列，队列中的元素需要实现Comparable和Delayed，存储元素时，可以设置在队列中存放的时间，
 * DelayQueue一般适用于定时任务和缓存系统设计
 * 
 * 场景：考试时间为120分钟，30分钟后才可交卷，当时间到了，或学生都交完卷了考试结束。
 *		这个场景中几个点需要注意：
 *		考试时间为120分钟，30分钟后才可交卷，初始化考生完成试卷时间最小应为30分钟
 *		对于能够在120分钟内交卷的考生，如何实现这些考生交卷
 *		对于120分钟内没有完成考试的考生，在120分钟考试时间到后需要让他们强制交卷
 *		在所有的考生都交完卷后，需要将控制线程关闭
 * @author lijh
 *
 */
public class MyDelayQueue2 {

    public static void main(String[] args) throws InterruptedException {
        int studentNumber = 20;
        CountDownLatch countDownLatch = new CountDownLatch(studentNumber+1);
        DelayQueue<Student> students = new DelayQueue<Student>();
        Random random = new Random();
        for (int i = 0; i < studentNumber; i++) {
            students.put(new Student("student"+(i+1), 30+random.nextInt(120),countDownLatch));
        }
        Thread teacherThread =new Thread(new Teacher(students)); 
        //初始化一个120分钟的Student对象，当超过120分钟，则会终止Teacher线程，强制交卷，
        //所以当Student对象的考试时间超过120分钟时，会强制交卷
        students.put(new EndExam(students, 120,countDownLatch,teacherThread));
        teacherThread.start();
        countDownLatch.await();
        System.out.println(" 考试时间到，全部交卷！");  
    }

}

class Student implements Runnable,Delayed{

    private String name;
    private long workTime;//
    private long submitTime;//延迟时间
    private boolean isForce = false;
    private CountDownLatch countDownLatch;
    
    public Student(){}
    
    public Student(String name,long workTime,CountDownLatch countDownLatch){
        this.name = name;
        this.workTime = workTime;
        this.submitTime = TimeUnit.NANOSECONDS.convert(workTime, TimeUnit.NANOSECONDS)+System.nanoTime();
        this.countDownLatch = countDownLatch;
    }
    
    /**
     * 根据学生考试时间排序
     * 	前面初始化了一个考试时间为120分钟的学生，当延迟队列取到这个学生时，结束Teacher线程，强制交卷
     */
    @Override
    public int compareTo(Delayed o) {
        if(o == null || ! (o instanceof Student)) return 1;
        if(o == this) return 0; 
        Student s = (Student)o;
        if (this.workTime > s.workTime) {
            return 1;
        }else if (this.workTime == s.workTime) {
            return 0;
        }else {
            return -1;
        }
    }

    /**
     * 返回剩余延迟时间，当剩余延迟时间为0或者负数时，代表延迟时间用尽了。
     */
    @Override
    public long getDelay(TimeUnit unit) {
    	//System.out.println(submitTime);
        return unit.convert(submitTime - System.nanoTime(),  TimeUnit.NANOSECONDS);
    }

    @Override
    public void run() {
        if (isForce) {
            System.out.println(name + " 交卷, 希望用时" + workTime + "分钟"+" ,实际用时 120分钟" );
        }else {
            System.out.println(name + " 交卷, 希望用时" + workTime + "分钟"+" ,实际用时 "+workTime +" 分钟");  
        }
        countDownLatch.countDown();
    }

    public boolean isForce() {
        return isForce;
    }

    public void setForce(boolean isForce) {
        this.isForce = isForce;
    }
    
}

/**
 * 此线程会结束Teacher线程，模拟强制交卷
 * @author lijh
 *
 */
class EndExam extends Student{

    private DelayQueue<Student> students;
    private CountDownLatch countDownLatch;
    private Thread teacherThread;
    
    public EndExam(DelayQueue<Student> students, long workTime, CountDownLatch countDownLatch,Thread teacherThread) {
        super("强制收卷", workTime,countDownLatch);
        this.students = students;
        this.countDownLatch = countDownLatch;
        this.teacherThread = teacherThread;
    }
    
    
    
    @Override
    public void run() {
        
        teacherThread.interrupt();
        Student tmpStudent;
        for (Iterator<Student> iterator2 = students.iterator(); iterator2.hasNext();) {
            tmpStudent = iterator2.next();
            tmpStudent.setForce(true);
            //调用Student线程的run方法，打印考试时间
            tmpStudent.run();
        }
        countDownLatch.countDown();
    }
    
}

/**
 * 监督学生考试线程
 * @author lijh
 *
 */
class Teacher implements Runnable{

    private DelayQueue<Student> students;
    public Teacher(DelayQueue<Student> students){
        this.students = students;
    }
    
    @Override
    public void run() {
        try {
            System.out.println(" test start");
            while(!Thread.interrupted()){
                students.take().run();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
}

5).同步队列 synchronousQueue

   

        synchronousQueue是一个不存储元素的阻塞队列，每一个poll()方法必须等待一个take()操作，否则不能继续poll()，适用于传递性设计，在这种设计中，在一个线程中运行的对象要将某些信息、事件或任务传递给在另一个线程中运行的对象，它就必须与该对象同步

package com.queue;

import java.util.Random;
import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.SynchronousQueue;

/**
 * 同步阻塞队列不会存储元素，每一个poll()方法必须等待一个take()操作，否则不能继续poll()
 * @author lijh
 *
 */
public class MySynchronousQueue {

    public static void main(String[] args) {
        final SynchronousQueue<String> synchronousQueue = new SynchronousQueue<String>();

        Producer3 p1 = new Producer3(synchronousQueue);

        Consumer3 p2 = new Consumer3(synchronousQueue);

        Consumer3 p3 = new Consumer3(synchronousQueue);
        
        //生成一个定长线程池
  		ExecutorService pool = Executors.newFixedThreadPool(3);
  		
  		pool.execute(p1);
  		pool.execute(p2);
  		pool.execute(p3);

    }
}

/**
 * 消费者
 * @author lijh
 *
 */
class Consumer3 implements Runnable {

    protected SynchronousQueue<String> blockingQueue;

    public Consumer3(SynchronousQueue<String> queue) {
        this.blockingQueue = queue;
    }

    @Override
    public void run() {
        while (true) {
            try {
            	//从同步队列中获取一个元素，如果队列中没有元素，则阻塞
                String data = blockingQueue.take();
                System.out.println(Thread.currentThread().getName()+ " take(): " + data);
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

/**
 * 生产者
 * @author lijh
 *
 */
class Producer3 implements Runnable {

    protected SynchronousQueue<String> blockingQueue;
    final Random random = new Random();

    public Producer3(SynchronousQueue<String> queue) {
        this.blockingQueue = queue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                String data = UUID.randomUUID().toString();
                System.out.println("Put: " + data);
                //往同步队列中插入一个元素，如果队列不为空则阻塞
                blockingQueue.put(data);
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

JiuShanCunMonkeyKing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 线程安全：BlockingQueue(阻塞算法) VS ConcurrentLinkedQueue(非阻塞算法)
robinjun的专栏
10-18 3133
Java提供的线程安全的Queue可以分为阻塞队列和非阻塞队列，其中阻塞队列的典型例子是BlockingQueue，非阻塞队列的典型例子是ConcurrentLinkedQueue，在实际应用中要根据实际需要选用阻塞队列或者非阻塞队列。 注：什么叫线程安全？这个首先要明确。线程安全的类 ，指的是类内共享的全局变量的访问必须保证是不受多线程形式影响的。如果由于多线程的访问（比如修改、遍历、查看
Java多线程（五）之BlockingQueue深入分析
08-10
Java多线程之BlockingQueue深入分析 Java多线程中，BlockingQueue是一种特殊的队列，它可以为线程同步提供有力的保障。在Java多线程（五）之BlockingQueue深入分析中，我们将深入分析BlockingQueue的定义、常用方法...
Java多线程之BlockingQueue
qingqingzijinxin的专栏
09-21 235
Java多线程之BlockingQueue
Java多线程-工具篇-BlockingQueue
一个人的专栏
01-23 320
详细参考：http://www.cnblogs.com/jackyuj/archive/2010/11/24/1886553.html
java 线程 block_针对Java多线程对BlockingQueue深入分析解析
weixin_39948277的博客
02-16 236
一、概述：BlockingQueue作为线程容器，可以为线程同步提供有力的保障。二、BlockingQueue定义的常用方法1.BlockingQueue定义的常用方法如下：抛出异常 特殊值 阻塞 超时插入 add(e) offer(e) put(e) offer(e, time, unit)移除 remove() poll() take() poll(time, unit)检查 element(...
java+arrayblockquene_Java源码分析-ArrayBlockingQueue
weixin_30394019的博客
02-26 50
ArrayBlockingQueue是JDK1.5开始concurrent包中提供的并发工具类，是一个基于数组的有界的先进先出队列，如果加入元素时，数组已满，或数组为空时，取元素都会阻塞当前线程，是一个典型的生产者消费者模式。类似的类还有LinkedBlockingQueue，PriorityBlockingQueue。继承关系public class ArrayBlockingQueue ext...
Java多线程编程实战指南-核心篇
06-10
Java的多线程能力是其强大之处，使得开发者能够在同一时间执行多个任务，提高程序效率。本指南将通过实例分析和实践演练，让你深入理解多线程的原理与应用。 首先，我们要了解Java中的线程模型。Java通过Thread类来...
Java多线程 BlockingQueue实现生产者消费者模型详解
08-25
Java多线程BlockingQueue实现生产者消费者模型详解 Java多线程中，生产者消费者模型是非常重要的一种设计模式，它可以解决多线程之间的数据传输问题。在Java中，我们可以使用BlockingQueue来实现生产者消费者模型，...
java 中 阻塞队列BlockingQueue详解及实例
08-30
总结来说，Java中的阻塞队列BlockingQueue是并发编程中的一种高效、线程安全的数据结构，它提供了线程间的同步和通信机制，简化了多线程环境下的编程复杂性。通过选择适当的实现类和使用适当的方法，开发者可以灵活...
Java多线程工具篇BlockingQueue的详解
08-26
BlockingQueue是Java多线程工具篇中的一种高效安全的队列类，在多线程环境中扮演着关键角色。它能够高效解决多线程中数据传输的问题，使得数据由队列的一端输入，从另外一端输出。本文将详细介绍BlockingQueue家庭...
BlockingQueue（阻塞队列）详解
11-19
在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue家庭中的所有成员，包括他们各自的功能以及常见使用场景。
线程安全队列Queue
01-17
在项目启动时，开一个单线程来专门处理巡检任务的下发给巡检服务组件。使用BlockingQueue阻塞算法。BlockingQueue作为线程容器，可以为线程同步提供有力的保障。
java blockqueue的使用_Java-BlockingQueue的使用
weixin_42301769的博客
02-28 264
每次都是隔很长时间才在博客中写点什么，说自己忙吧，这是给自己的一个借口，其实呢还是懒啊。哎。。。最近项目中有个对比的需求，需要从日志文件中获取到参数，然后调用不同的API，进行结果的对比。但是不知用什么方式比较好，于是查了下jdk的手册，发现了BlockingQueue这个好东西。关于BlockingQueue的介绍，大家有兴趣的可以自己看下：http://docs.oracle.com/java...
java queue iterator_Java中的ArrayBlockingQueue iterator()方法
weixin_42188533的博客
02-24 126
iterator()ArrayBlockingQueue类的方法以适当的顺序返回对该队列中的元素的迭代器。语法如下。publicIteratoriterator()要使用ArrayBlockingQueue类，您需要导入以下包。importjava.util.concurrent.ArrayBlockingQueue;以下是实现iterator()Java ArrayBlockingQueu...
java queue iterator_Java LinkedBlockingQueue iterator()用法及代码示例
weixin_30499557的博客
02-24 159
LinkedBlockingQueue的iterator()方法以正确的顺序返回与此LinkedBlockingQueue相同的元素的迭代器。从此方法返回的元素按从LinkedBlockingQueue的first(head)到last(tail)的顺序包含所有元素。返回的迭代器是弱一致性的。用法:public Iterator iterator()返回值：该方法按从first(head)到las...
java blockqueue_Java并发集合_BlockingQueue原理分析
weixin_33642697的博客
02-23 226
假如我们现在有这样的需求，有一个仓库，我们可以存东西和取东西，仓库有存储上限。当仓库已满的时候，存东西的人就必须等待，直到有人取走东西。当仓库为空的时候，取东西的人必须等待，直到有人存入东西。这是一个典型的生产者消费者问题。这里有两个条件，仓库已满的条件和仓库为空的条件，用条件让线程等待，这个让我们想到了并发框架下的Condition。自己实现这个功能也不难，但是java中给我们提供了很好的实现，...
【Java】简析ThreadPoolExecutor execute和BlockQueue
baofeidyz
05-04 632
介绍线程池的五种状态以及状态的二进制表达以及切换等。 阻塞队列常用的数组实现以及链表实现的源码解析
Java并发7：阻塞队列BlockingQueue
Yisnow.的博客
08-09 276
1、BlockingQueue BlockingQueue 是一个先进先出的队列（Queue），为什么说是阻塞（Blocking）的呢？是因为 BlockingQueue 支持当获取队列元素但是队列为空时，会阻塞等待队列中有元素再返回；也支持添加元素时，如果队列已满，那么等到队列可以放入新元素时再放入。 BlockingQueue 是一个接口，继承自 Queue，所以其实现类也可以作为 Queue 的实现来使用，而 Queue 又继承自 Collection 接口。 BlockingQueue 不接受 nu
阻塞队列（BlockingQueue）的实现和使用
闲来垂钓碧溪上的博客
03-29 649
阻塞队列是可以用于存放线程，因为阻塞队列可以对线程安全进行一种保护策略，当一个在队列中取一个线程时，如果阻塞队列中无线程，则会陷入等待状态，也就是阻塞，同样的，当队列空间满了之后，想要再加入线程，也会进入等待状态。”，高内聚是指代码的分布比较均匀，一个功能的代码就聚合在一起，使得程序员想修改一段代码时，可以轻易找到，也就是指关联代码分门别类的规制起来。可以正常使用，这里我们主要讲解了阻塞队列的实现以及使用，和阻塞队列与普通队列的区别，还有阻塞队列的线程安全问题。与队列相同，阻塞队列只是增加了。
java多线程阻塞队列
最新发布
09-22
阻塞队列（BlockingQueue）是Java多线程编程中的一个重要概念。它是一个支持在多线程环境下安全地进行数据存取的队列。当阻塞队列为空时，从队列中获取元素的操作将会被阻塞；当阻塞队列满时，往队列中添加元素的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值