java线程通信总结

最新推荐文章于 2023-01-08 22:00:45 发布
最新推荐文章于 2023-01-08 22:00:45 发布
阅读量477 收藏 1
点赞数
分类专栏： java多线程与并发 文章标签： java 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21225505/article/details/123974394
版权

一、线程之间如何工作

  大家都知道计算机的核心是CPU，它承担着计算机所搜的计算任务， 而操作系统负责计算机任务的调度，资源管理与分配。

  进程是一个具有独立功能的程序，是操作系统进行资源分配和调度的基本单位，是应用程序的载体，比如微信、IDEA等运行都属于进程的范畴。进程是任务调度的最小单位，每个进程都有属于自己的一块独立内存，各个进程之间是相互隔离的。线程则是程序执行中一个单一的的顺序控制流程，是程序执行的最小单元，是处理器调度的最小单元。一个进程可以有一个或多个线程，多个线程之间共享进程的内存空间。举个例子，微信能够保证用户刷视频的同时，及时接收好友信息，可以简单理解为微信（进程）拥有俩个执行中的线程。

二、线程状态如何切换

  线程运行过程中会经历创立、运行、暂停、销毁等几个阶段 

  上图为大家展示了线程运行过程中的几种状态，其中wait()方法的作用是使得当前执行代码的线程进入等待（暂停），直到接到notify()方法通知或者被中断为止。需要注意的是，在上述俩个方法，只能在同步方法或者同步代码块中执行，即必须获得对象级别锁

  每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列。就绪队列存储了将要获得锁的进程，阻塞队列存储了被阻塞的进程。一个线程被唤醒后，才会进入就绪队列，等待CPU的调度；反之，一个线程被wait后，就会进入阻塞队列，等待下一次被唤醒。

三、线程间通信

  线程通信的有以下几种

1、共享变量

  第一类：使用volatile关键字实现   示例代码如下：

public class RunThread extends Thread{

	private volatile boolean isRunning = true;
	private void setRunning(boolean isRunning){
		this.isRunning = isRunning;
	}
	
	public void run(){
		System.out.println("进入run方法..");
		int i = 0;
		while(isRunning == true){
			//..
		}
		System.out.println("线程停止");
	}
	
	public static void main(String[] args) throws InterruptedException {
		RunThread rt = new RunThread();
		rt.start();
		Thread.sleep(1000);
		rt.setRunning(false);
		System.out.println("isRunning的值已经被设置了false");
	}
	
}

  不加volatile关键字，while循环不会停止。该关键字使得isRunning对其它进程可见，当其它进程对变量进行修改后，线程会强制执行把共性内存内的变量值重新读取一遍，加载到自身的工作内存中。

但是 volatile关键字不具有同步性，一般只用于多线程的变量读操作，并不能代替synchronize关键字的同步性

  第二类：使用synchronized/wait/notify实现

  对于生产者-消费者问题，有两个要点需要注意：

  第一，在多个同类型线程（多个生产者线程或者消费者线程）的场景中，为防止wait的条件发生变化而导致线程异常终止，我们在阻塞线程被唤醒的同时还必须对wait的条件进行额外的检查，即 使用 while 循环代替 if条件；

  第二，在多个同类型线程（多个生产者线程或者消费者线程）的场景中，为防止生产者(消费者)仅唤醒生产者(消费者)，保证生产者和消费者互相唤醒，需要 使用 notifyAll 替代 notify。

  示例代码如下：

public class Demo1 {

    private final List<Integer> list =new ArrayList<>();

    public static void main(String[] args) {
        Demo1 demo =new Demo1();
        new Thread(()->{
            for (int i=0;i<10;i++){
                synchronized (demo.list){
                   // if(demo.list.size()%2==1){
                    while(demo.list.size()%2==1){
                        try {
                            demo.list.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    demo.list.add(i);
                    System.out.print(Thread.currentThread().getName());
                    System.out.println(demo.list);
                    //demo.list.notify();
                    demo.list.notifyAll();
                }
            }

        }).start();

        new Thread(()->{
            for (int i=0;i<10;i++){
                synchronized (demo.list){
                    //if(demo.list.size()%2==0){
                    while(demo.list.size()%2==0){
                        try {
                            demo.list.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    demo.list.add(i);
                    System.out.print(Thread.currentThread().getName());
                    System.out.println(demo.list);
                    //demo.list.notify();
                    demo.list.notifyAll();
                }
            }
        }).start();
    }
}

输出结果如下：

Thread-0[0]
Thread-1[0, 0]
Thread-0[0, 0, 1]
Thread-1[0, 0, 1, 1]
Thread-0[0, 0, 1, 1, 2]
Thread-1[0, 0, 1, 1, 2, 2]
Thread-0[0, 0, 1, 1, 2, 2, 3]
Thread-1[0, 0, 1, 1, 2, 2, 3, 3]
Thread-0[0, 0, 1, 1, 2, 2, 3, 3, 4]
Thread-1[0, 0, 1, 1, 2, 2, 3, 3, 4, 4]
Thread-0[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5]
Thread-1[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
Thread-0[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6]
Thread-1[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6]
Thread-0[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7]
Thread-1[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7]
Thread-0[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
Thread-1[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8]
Thread-0[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9]
Thread-1[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9]

  此类通信方式属于等待/通知机制，不同于volatile关键字的实现机制。第一类实现方式是多个线程主动读取一个共享变量，在花费时间读取变量的基础上，加上while等条件判断语句，并不能保证读到的变量是预期结果。

  如果有多个线程等待，则由线程规划器随机挑选出其中一个呈wait状态的线程，对其发出通知notify，并使它等待获取该对象的对象锁。需要说明的是，在执行notify()方法后，当前线程不会马上释放该对象锁，呈wait状态的线程也并不能马上获取该对象锁，到等到执行notify()方法的线程将程序执行完，也就是退出synchronized代码块后，当前线程才会释放锁，而呈wait状态所在的线程才可以获取该对象锁。

  第三类：使用lock/Condition实现

  相比使用Object的wait()/notify()，使用Condition的await()/signal()这种方式能够更加安全和高效地实现线程间协作。 Condition是个接口，基本的方法就是await()和signal()方法。Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition() 。

  必须要注意的是，Condition 的 await()/signal() 使用都必须在lock保护之内，也就是说，必须在lock.lock()和lock.unlock之间才可以使用。

  示例代码如下：

public class Task {
    private final Lock lock = new ReentrantLock();

    private final Condition addConditon = lock.newCondition();
    private final Condition subConditon = lock.newCondition();

    private volatile int num = 0;
    private List<String> list = new ArrayList<>();

    public void add() {
        for (int i = 0; i < 10; i++) {
            lock.lock();

            try {
                if (list.size() == 10) {
                    addConditon.await();
                }
                num++;
                Thread.sleep(100);
                list.add("add " + num);
                System.out.println("The list size is " + list.size());
                System.out.println("The add thread is " + Thread.currentThread().getName());
                System.out.println("-------------");
                subConditon.signal();

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

    public void sub() {
        for (int i = 0; i < 10; i++) {
            lock.lock();

            try {

                if (list.size() == 0) {
                    subConditon.await();
                }
                num--;
                Thread.sleep(100);
                list.remove(0);
                System.out.println("The list size is " + list.size());
                System.out.println("The sub thread is " + Thread.currentThread().getName());
                System.out.println("-------------");
                addConditon.signal();

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


    public static void main(String[] args) {
        Task task = new Task();
        new Thread(task::add).start();
        new Thread(task::sub).start();
    }
}

输出结果如下：

The list size is 1
The add thread is Thread-0
-------------
The list size is 2
The add thread is Thread-0
-------------
The list size is 3
The add thread is Thread-0
-------------
The list size is 4
The add thread is Thread-0
-------------
The list size is 5
The add thread is Thread-0
-------------
The list size is 6
The add thread is Thread-0
-------------
The list size is 5
The sub thread is Thread-1
-------------
The list size is 6
The add thread is Thread-0
-------------
The list size is 7
The add thread is Thread-0
-------------
The list size is 8
The add thread is Thread-0
-------------
The list size is 9
The add thread is Thread-0
-------------
The list size is 8
The sub thread is Thread-1
-------------
The list size is 7
The sub thread is Thread-1
-------------
The list size is 6
The sub thread is Thread-1
-------------
The list size is 5
The sub thread is Thread-1
-------------
The list size is 4
The sub thread is Thread-1
-------------
The list size is 3
The sub thread is Thread-1
-------------
The list size is 2
The sub thread is Thread-1
-------------
The list size is 1
The sub thread is Thread-1
-------------
The list size is 0
The sub thread is Thread-1
-------------

  使用Condition往往比使用传统的通知等待机制(Object的wait()/notify())要更灵活、高效，也可以使用多个Condition实现通知部分线程

  第四类：使用PipedInputStream/PipedOutputStream实现

  PipedInputStream类与PipedOutputStream类用于在应用程序中创建管道通信。一个PipedInputStream实例对象必须和一个PipedOutputStream实例对象进行连接而产生一个通信管道。

  PipedOutputStream可以向管道中写入数据，PipedIntputStream可以读取PipedOutputStream向管道中写入的数据，这两个类主要用来完成线程之间的通信。 PipedInputStream和PipedOutputStream的实现原理类似于”生产者-消费者”原理，PipedOutputStream是生产者，PipedInputStream是消费者。


public class Test {
    public static void main(String[] args) {
        try {
            PipedInputStream inputStream = new PipedInputStream();
            PipedOutputStream outputStream = new PipedOutputStream();
 
            // inputStream.connect(outputStream);   // 效果相同
            outputStream.connect(inputStream);
 
            ThreadRead threadRead = new ThreadRead( inputStream);
            threadRead.start();
 
            Thread.sleep(2000);
 
            ThreadWrite threadWrite = new ThreadWrite( outputStream);
            threadWrite.start();
 
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

//读线程


class ThreadRead  extends Thread {

  private PipedInputStream input;

  public ThreadRead ( PipedInputStream input) {
      super();
      this.input = input;
  }

  public void readMethod(PipedInputStream input) {
      try {
          System.out.println("readMethod begin  :");
          byte[] byteArray = new byte[20];
          int readLength = input.read(byteArray);
          while (readLength != -1) {
              String newData = new String(byteArray, 0, readLength);
              System.out.print(newData);
              readLength = input.read(byteArray);
          }
          System.out.println();
          System.out.println("readMethod end  :");
          input.close();
      } catch (IOException e) {
          e.printStackTrace();
      }
  }

  @Override
  public void run() {
      this.readMethod(input);
  }
}

//写线程
class ThreadWrite extends Thread {

  private PipedOutputStream out;

  public ThreadWrite( PipedOutputStream out) {
      super();
      this.out = out;
  }

  public void writeMethod(PipedOutputStream out) {
      try {
          System.out.println("writeMethod begin :");
          for (int i = 0; i < 30; i++) {
              String outData = "" + (i + 1);
              out.write(outData.getBytes());
              System.out.print(outData);
          }
          System.out.println();
          System.out.println("writeMethod end :");
          out.close();
      } catch (IOException e) {
          e.printStackTrace();
      }
  }

  @Override
  public void run() {
      this.writeMethod(out);
  }
}

输出结果如下：

readMethod begin  :
writeMethod begin :
123456789101112131415161718192021222324252627282930
writeMethod end :
123456789101112131415161718192021222324252627282930
readMethod end  :

  第五类：使用BlockingQueue实现

BlockingQueue定义的常用方法如下:

  • add(Object)：把Object加到BlockingQueue里，如果BlockingQueue可以容纳，则返回true，否则抛出异常。
  • offer(Object)：表示如果可能的话，将Object加到BlockingQueue里，即如果BlockingQueue可以容纳，则返回true，否则返回false。
  • put(Object)：把Object加到BlockingQueue里，如果BlockingQueue没有空间，则调用此方法的线程被阻断直到BlockingQueue里有空间再继续。
  • poll(time)：获取并删除BlockingQueue里排在首位的对象，若不能立即取出，则可以等time参数规定的时间，取不到时返回null。当不传入time值时，立刻返回。
  • peek()：立刻获取BlockingQueue里排在首位的对象，但不从队列里删除，如果队列为空，则返回null。
  • take()：获取并删除BlockingQueue里排在首位的对象，若BlockingQueue为空，阻断进入等待状态直到BlockingQueue有新的对象被加入为止。

BlockingQueue有四个具体的实现类：

  • ArrayBlockingQueue：数组阻塞队列，规定大小，其构造函数必须带一个int参数来指明其大小。其所含的对象是以FIFO（先入先出）顺序排序的。
  • LinkedBlockingQueue：链阻塞队列，大小不定，若其构造函数带一个规定大小的参数，生成的BlockingQueue有大小限制，若不带大小参数，所生成的BlockingQueue的大小由Integer.MAX_VALUE来决定。其所含的对象是以FIFO顺序排序的。
  • PriorityBlockingQueue：类似于LinkedBlockingQueue,但其所含对象的排序不是FIFO，而是依据对象的自然排序顺序或者是构造函数所带的Comparator决定的顺序。
  • SynchronousQueue：特殊的BlockingQueue，它的内部同时只能够容纳单个元素，对其的操作必须是放和取交替完成的。
  • DelayQueue：延迟队列，注入其中的元素必须实现 java.util.concurrent.Delayed 接口
public class BlockingQueueDemo {

    public static void main(String[] args) {
        LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<>();
        //读线程
        new Thread(() -> {
            int i =0;
            while (true) {
                try {
                    String item = queue.take();
                    System.out.print(Thread.currentThread().getName() + ": " + i + " ");
                    System.out.println(item);
                    i++;
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        //写线程
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    String item = "go"+i;
                    System.out.print(Thread.currentThread().getName() + ": " + i + " ");
                    System.out.println(item);
                    queue.put(item);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

以上内容参考文章：

进程与线程 - 浅浅念 - 博客园
Java中的ThreadLocal详解 - 夏末秋涼 - 博客园
java线程间通讯的几种方式_顽石九变的博客-CSDN博客_java线程间的通信方式三种
Java多线程编程（三）线程间通信 - BigJunOba - 博客园
JAVA线程通信详解_抽离的心的博客-CSDN博客_java线程通信

 

皓月星辰_w
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java通信方式总结例程
03-20
Java通信方式总结Demo，包括RPC、RMI、Socket以及线程间的通信方式等
Java学习总结：多线程和网络编程
u010743397的博客
07-21 608
1、多线程概述什么是多线程？？？ 一个应用程序有多条执行路径，线程是依赖于进程而存在的。 二、多线程的实现方式一 1、创建多线程的方式一？ A创建一个类这个类继承Thread类 B重写run方法 C启动线程并执行stat（）方法做了几件事？ 启动线程，自动调用run方法线程越多越好吗？ 不是，因为没开一个线程系统必然会为它分配内存。Thread类下setName，getName方法
Java通信方式总结
Mr.X
03-20 5664
Java通信方式总结 1 Java对象、方法间通信方式 1.1 值传递、引用传递 （1）值传递：将副本传递给方法，调用方法改变副本的值，但是并不改变原值 （2）引用传递：传递的是对象（或者变量）的引用，对其修改，会改变原值 从内存分配的角度讲解Java中只存在值传递，不存在引用传递 1.2 浅拷贝、深拷贝 （1）浅拷贝：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝。 （2）深拷贝：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容
Java线程间的通信方式
Wdradon的博客
06-27 5035
**定义：**当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以避免无效的资源争夺。通信的方式：**线程同步：**即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作。同步的话，仅仅传递的是控制信息，就是我什么时候运行结束，你什么时候可以来。对于线程间通信来说，线程间同步可以归纳为线程间通信的一个子集，对于线程通信指的是两个线程之间可以交换一些实时的数据信息，而线程同步只交换一些控制信息。在java中有几个关于
Java线程通信的几种方式
Admans的专栏
06-29 4484
有两个线程，A 线程向一个集合里面依次添加元素“abc”字符串，一共添加十次，当添加到第五次的时候，希望 B 线程能够收到 A 线程的通知，然后 B 线程执行相关的业务操作。线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。基于 volatile 关键字来实现线程间相互通信是使用共享内存的思想。大致意思就是多个线程同时监听一个变量，当这个变量发生变化的时候 ，线程能够感知并执行相应的业务。这也是最简单的一种实现方式 Object 类提供了线程间通信的方法：wait()、no
Java并发学习 7: 线程之间的通信
过道
04-10 2804
3.1 继承 Thread类 // 继承，则Demo1 也成为了一个线程 public class Demo1 extends Thread { // 继承Thread类，需要重写run()方法，告诉这个类需要去坐什么. @Override public void run() { // 这个新类，只需要打印出自己的名字(每个线程都有自己的Name属性并提供g...
Java_多线程与并发编程总结.doc
04-14
对于一个进程中的多个线程来说，多个线程共享进程的内存块，当有新的线程产生的时候，操作系统不分配新的内存...因此，线程间的通信很容易，速度也很快。不同的进程因为处于不同的内存块，因此进程之间的通信相对困难。
java多线程核心技术
01-19
资深Java专家10年经验总结，全程案例式讲解，首本全面介绍Java多线程编程技术的专著 结合大量实例，全面讲解Java多线程编程中的并发访问、线程间通信、锁等最难突破的核心技术与应用实践 Java多线程无处不在，如...
整理总结Java多线程程序编写的要点
09-02
主要介绍了Java多线程程序编写的要点,包括线程的状态控制和优先级以及线程的通信问题等方面,非常之全面!需要的朋友可以参考下
java学习中对线程的总结
08-14
线程在移动开发中有很重要的作用，理解线程对于网络通信来说是必不可少的
【Java多线程】你知道实现Java线程间通信有多少种方法吗？
aaa_hao的博客
03-24 4079
文章目录1. 锁与同步2. 等待/通知机制3. 信号量4. 管道5. 其它通信相关5.1 join() 方法5.2 sleep() 方法sleep() 与 wait() 的区别5.3 ThreadLocal 类5.4 InheritableThreadLocal 合理地使用 Java 多线程可以更好地利用服务器资源。一般来讲，线程内部有自己私有的线程上下文，互不干扰。但是当我们需要多个线程之间相互协作的时候，就需要掌握 Java 线程的通信方式。下文将介绍 Java 线程之间的几种通信机制和原理。 1. 锁
面试官问：Java线程中如何保证通信，都有哪些方式？
Java精选
01-08 231
一、介绍本文总结我对于JAVA多线程中线程之间的通信方式的理解，主要以代码结合文字的方式来讨论线程间的通信，故摘抄了书中的一些示例代码。二、线程间的通信方式①同步这里讲的同步是指多个线程通过synchronized关键字这种方式来实现线程间的通信。参考示例：public class MyObject { synchronized public void methodA() { ...
Java 线程间的通信机制详解
swadian2008的博客
08-21 2638
目录1、volatile 关键字2、等待唤醒（等待通知）机制（1）wait() 和 notify() 等待唤醒（2）park() 和 unpark() 等待唤醒3、join() 方法——线程排队4、管道输入输出流5、ThreadLocal类和InheritableThreadLocal类线程间通信使线程成为一个整体，提高系统之间的交互性，在提高CPU利用率的同时可以对线程任务进行有效的把控与监督。volatile有两大特性，一是可见性，二是有序性，禁止指令重排序。其中可见性就是可以让线程之间进行通信。以下两
深入理解Java线程间通信
BASK2311的博客
11-25 967
合理的使用Java多线程可以更好地利用服务器资源。一般来讲，线程内部有自己私有的线程上下文，互不干扰。但是当我们需要多个线程之间相互协作的时候，就需要我们掌握Java线程的通信方式。本文将介绍Java线程之间的几种通信原理。
java线程的通信_java线程之间的通信
weixin_34861332的博客
02-20 70
1.常用的方法sleep() 该线程进入等待状态,不释放锁wait()该线程进入等待状态,释放锁notify()随机唤醒一个线程notifyAll()唤醒全部线程getName()获取线程对象的名称。默认情况下，名字的组成 Thread-编号(编号从0开始)setName(String name)设置线程名称currentThread()返回当前正在执行的线程对象引用sleep(Long time...
Java 进程间通信总结
一笑悬命的专栏
09-13 2298
标题Java 进程间通信总结 总结Java常见的进程间通信方式，方便面试总结。内容均来源于网络，感谢大家的分享 目录 文章目录标题Java 进程间通信总结链接管道(PIPE)Semaphore(信号量)MessageQueue共享内存(SharedMemory)socket 链接 https://blog.csdn.net/u011490072/article/details/89508714 （Java进程之间通信方式&线程之间通信的方式） https://www.jianshu.com/p/e
java实现线程间通信的四种方式
Hadwin1991的博客
06-21 1万+
java实现线程间通信的三种方式
Java中的多线程（线程间通信）
热门推荐
不思量
09-23 2万+
线程间通信： /学习笔记/ 多个线程在处理同一资源，但是任务却不同。 先看一个例子，采用两个线程执行进行输入和输出任务： //资源 class Resource { String name; String sex; } //输入 class Input implements Runnable { Resource r ; // Object o...
JAVA线程之间的通信
qq_42682991的博客
11-28 4161
线程通信涉及到的三个方法： （1）wait():一旦执行此方法当前线程进入阻塞状态，并释放同步监视器 （2）notify()：一旦执行此方法就会唤醒被wait的另一个线程。如果存在多个被wait的线程，唤醒优先级高的线程。 （3）notifyAll()：一旦执行此方法就会唤醒所有被wait的线程 说明： （1）wait()、notify()、notifyAll()三个方法必须在同步代码块或同步方法里面使用 （2）wait()、notify()、notifyAll()三个方法的调用者必须是同步代码块或同步.
android 线程通信
最新发布
07-27
总结起来，Android中线程通信可以通过Handler和Looper机制实现主线程和子线程之间的通信，也可以使用HandlerThread实现子线程之间的通信。这些机制可以帮助开发者更好地处理多线程编程中的同步问题。\[1\] #### 引用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

皓月星辰_w

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

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

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

打赏作者

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

抵扣说明：

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

余额充值