java设计模式之单例模式

最新推荐文章于 2023-06-06 20:30:39 发布
最新推荐文章于 2023-06-06 20:30:39 发布
阅读量214 收藏
点赞数
文章标签： java 单例模式 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/J_Newbie/article/details/126636775
版权

定义：

单例模式指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点，属于创建型设计模式

应用场景：

  1. 需要频繁的创建一些类，使用单例模式可以降低系统的内存压力，减少GC

  2. 某些类创建实例时占用资源比较多，或实例化耗时较长，且经常使用。

  3. 频繁访问数据库或者文件的对象

  4. 对于一些控制硬件级别的操作，或者从系统上来讲应当是单一控制逻辑的操作，如果有多个实例，则系统会完全乱套

UML类图：

通用写法：

public class Client{
  public static void main(String[] args){
    Singleton.getInstance();
  }
  static class Singleton(){
    private static final Singleton instance = new Singleton();
    
    private Singleton(){};
    
    public static Singleton getInstance(){
      return instance;
    }
  }
}

使用单例模式解决实际问题：

饿汉式单例写法的弊端： 

上面的通用型写法就是标准的饿汉式写法。饿汉式单例写法在类加载的时候立即初始化，并且创建单例对象。他绝对线程安全，在线程还没有出现之前就实例化了，不可能存在访问安全问题。饿汉式还有一种写法，代码如下：

//饿汉式静态块单例模式
public class Singleton{
  private static final Singleton singleton;
  static{
    singleton = new Singleton();
  }
  private Singleton(){};
  
  public static Singleton getInstance(){
    return singleton;
  }
}

这种写法的静态块机制，非常简单也容易理解。饿汉式单例写法适用于单例对象比较少的情况，这样写可以保证绝对的线程安全。执行效率比较高。但是它的缺点明显，就是所有对象都会在类加载的时候创建实例化，这样一来，系统中就会有大量的实例化单例对象存在，而且单例对象的数量也不确定，则系统初始化时会造成大量的内存浪费，从而导致系统内存不可控。也就是说，不管对象用不用，都会占用空间，浪费了内存。

懒汉式写法：

//懒汉式单例在外部需要使用的时候才会进行实例化
public class LazySingleton{
  private LazySingleton(){}
  //静态块，公共内存区域
  private static LazySingleton lazySingleton = null;
  
  public static LazySingleton getInstance(){
    if(lazySingleton == null){
      lazySingleton = new LazySingleton();
    }
    return lazySingleton;
  }
}

但这样写又带来一个新的问题，如果在多线程环境下，则会出现线程安全问题。我们来模拟一下，编写线程类ExectorThread

public class ExectorThread implements Runnable{
  @Override
  public void run(){
    LazySingleton lazySingleton = LazySingleton.getInstance();
    System.out.println(Thread.currentThread().getName() + ":" + lazySingleton);
  }
}

客户端测试代码：

public class LazySingletonTest{
  public static void main(String[] args){
    Thread t1 = new Thread(new ExectorThread());
    Thread t2 = new Thread(new ExectorThread());
    t1.start();
    t2.start();
    System.out.println("End");
  }
}

运行多次出现的结果：

End
Thread-0:com.design.pattern.singleton.LazySingleton@92734f7
Thread-1:com.design.pattern.singleton.LazySingleton@6a2ff6fb

这意味着上面的单例模式存在着线程安全的隐患。那么结果是怎么产生的。我们分析一下：

如果两个线程在同一时间进入getInstance（）方法，则会同时满足if（lazySingleton == null）的条件，创建两个对象。如果两个线程继续执行往下代码，则又可能后执行线程的结果覆盖先执行的线程的结果，如果打印发生在覆盖之前，则最终的结果就是一致的。如果发生在打印发生在覆盖之后，就会得到两个不同的结果。

当然也有可能没有发生并发，正常运行。

如何优化代码，使得懒汉式单例写法在线程环境下是安全的呢？来看下面代码，给getInstance（）方法加上synchronized关键字，使这个方法变成线程同步方法。

public class LazySingleton{
  private LazySingleton(){}
  //静态块，公共内存区域
  private static LazySingleton lazySingleton = null;
  
  public synchronized static LazySingleton getInstance(){
    if(lazySingleton == null){
      lazySingleton = new LazySingleton();
    }
    return lazySingleton;
  }
}

这样就解决了线程安全的问题。

双重检查锁单例写法：

上面通过给方法加synchronized的方法解决线程问题，但是在线程数据剧增的情况下，用synchronized加锁，则会导致程序性能的大幅下降。所以引入了双重检查的方式

public class Singleton{
  private volatile static Singleton instance;
  private Singleton(){};
  public static Singleton getInstance(){
    synchronized(Singleton.class){
      if(instance == null){
        instance = new Singleton();
      }
    }
    return instance;
  }
}

这样的写法其实与在方法上加synchronized并无差异，还是会造成大规模的阻塞。我们把判断条件往上提一级

public class LazyDoubleCheckSingleton{
  private volatile static LazyDoubleCheckSingleton instance;
  private LazyDoubleCheckSingleton(){}
  public static LazyDoubleCheckSingleton getInstance(){
    if(instance == null){
      synchronized(LazyDoubleCheckSingleton.class){
        instance = new LazyDoubleCheckSingleton();
      }
    }
    return instance;
  }
}

运行代码后，还是会存在线程安全问题。这是为什么呐，其实如果两个线程同一时间都满足if(instance == null)条件，则两个线程都会执行 synchronized块中的代码，因此，还是会创建两次，再优化一下代码

public class LazyDoubleCheckSingleton{
  private volatile static LazyDoubleCheckSingleton instance;
  private LazyDoubleCheckSingleton(){}
  public static LazyDoubleCheckSingleton getInstance(){
    //检查是否要阻塞
    if(instance == null){
      synchronized(LazyDoubleCheckSingleton.class){
        //检查是否要创建实例
        if(instance == null){
          instance = new LazyDoubleCheckSingleton();
          //指令重排序的问题
        }
      }
    }
    return instance;
  }
}

当第一个线程调用getInstance（）方法时，第二个线程也可以调用，当第一个线程执行到synchronized时会上锁。第二个线程就会变成MONITOR状态，出现阻塞。此时，阻塞并不是基于整个LazyDoubleCheckSingleton类的阻塞，而是在getInstance（）方法内部的阻塞，只要逻辑不太复杂，对于调用者而言感觉不到。

双重检查锁单例写法虽然解决了线程安全的问题和性能问题，但是只要用到synchronized关键字就总是要上锁，对程序的性能还是存在一定的影响。我们从类初始化的角度考虑下面代码，采用静态内部类的方式：

//这种形式兼顾了饿汉式单例写法的内存浪给问题和synchronized的性能问题
//完美的屏蔽了这两个缺点
public class LazyStaticInnerClassSingleton{
  //使用LazyInnerClassGeneral的时候，默认会初始化内部类
  //如果没使用，则内部类是不加载的
  private LazyStaticInnerClassSingleton(){};
  //每一个关键字都不是多余的，static是为了使单例模式的空间共享，保证这个写法不会被重写，重载
  private static LazyStaticInnerClassSingleton getInstance(){
    //返回结果前，一定会先加载内部类
    return LazyHolder.INSTANCE;
  }
  //利用了java本身的语法特点，默认不加载内部类
  private static class LazyHolder{
    private static final LazyStaticInnerClassSingleton INSTANCE = new LazyStaticInnerClassSingleton();
  }
}

这种方式兼顾了饿汉式单例写法的内存浪费问题和synchronized的性能问题，内部类一定要在方法调用之前被初始化，巧妙的避免了线程安全问题。

还原反射破坏单例模式的事故现场：

上面的单例模式的构造方法除了加上private关键字，没有坐任何处理，我们如果用反射调用起构造方法，在调用getInstance方法，应该会有两个不同的实例。客户端代码如下：以LazyStaticInnerClassSingleton为例：

public static void main(String[] args){
  try{
    Class<?> clazz = LazyStaticInnerClassSingleton.class;
    Constructor c = clazz.getDeclaredConstructor(null);
    c.setAccessible(true);
    Object o1 = c.newInstance();
    Object o2 = c.newInstance();
    //调用了两次构造方法，相当于new了两次，犯了原则性错误
    System.out.println(o1 == o2);
  }catch(Exception e){
    e.printStackTrace();
  }
}

运行结果

false

我们做一次优化，我们在其构造方法中做一些限制，一旦出现多次重复创建，则直接抛出异常，优化后代码如下：

//这种形式兼顾了饿汉式单例写法的内存浪给问题和synchronized的性能问题
//完美的屏蔽了这两个缺点
public class LazyStaticInnerClassSingleton{
  //使用LazyInnerClassGeneral的时候，默认会初始化内部类
  //如果没使用，则内部类是不加载的
  private LazyStaticInnerClassSingleton(){
    if(LazyHolder.INSTANCE != null){
      throw new RuntimeException("不允许创建多个实例");
    }
  };
  //每一个关键字都不是多余的，static是为了使单例模式的空间共享，保证这个写法不会被重写，重载
  private static LazyStaticInnerClassSingleton getInstance(){
    //返回结果前，一定会先加载内部类
    return LazyHolder.INSTANCE;
  }
  //利用了java本身的语法特点，默认不加载内部类
  private static class LazyHolder{
    private static final LazyStaticInnerClassSingleton INSTANCE = new LazyStaticInnerClassSingleton();
  }
}

测试结果如下：

java.lang.reflect.InvocationTargetException
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
	at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
	at com.design.pattern.singleton.Test.main(Test.java:11)
Caused by: java.lang.RuntimeException: 不允许创建多个实例
	at com.design.pattern.singleton.LazyStaticInnerClassSingleton.<init>(LazyStaticInnerClassSingleton.java:10)
	... 5 more

但是会抛出异常，不够优雅。

更加优雅的枚举式单例写法：

枚举式单例的标准写法，创建EnumSingleton类：

public enum EnumSingleton{
  INSTANCE;
  private Object data;
  public Object getData(){
    return data;
  }
  public void setData(Object data){
    this.data = data;
  }
  public static EnumSingleton getInstance(){
    return INSTANCE;
  }
}

客户端测试代码：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class TestEnumSingleton{
  public static void main(String[] args){
    try{
      EnumSingleton instance1 = null;
      EnumSingleton instance2 = EnumSingleton.getInstance();
      instance2.setData(new Object());

      FileOutputStream fos = new FileOutputStream("EnumSingleton.obj");
      ObjectOutputStream oos = new ObjectOutputStream(fos);
      oos.writeObject(instance2);
      oos.flush();
      oos.close();

      FileInputStream fis = new FileInputStream("EnumSingleton.obj");
      ObjectInputStream ois = new ObjectInputStream(fis);
      instance1= (EnumSingleton) ois.readObject();
      ois.close();
      System.out.println(instance1.getData());
      System.out.println(instance2.getData());
      System.out.println(instance1.getData() == instance2.getData());
    }catch(Exception e){
      e.printStackTrace();
    }
  }
}

测试结果：

java.lang.Object@6acbcfc0
java.lang.Object@6acbcfc0
true

还原反序列化破坏单例模式的事故现场：

一个单例对象创建好后，有时候需要讲对象序列化然后写入磁盘，当下次使用时再从磁盘中读取对象并进行反序列化，将其转化为内存对象。反序列化的对象会重新分配内存，即重新创建。如果序列化的目标为单例对象，则违背了单例模式的初衷，相当于破坏了单例模式：如下代码“

//反序列化破坏了单例模式
public class SeriableSingleton implements Serializable{
  //序列化就是把内存中的状态通过转换成字节码的形式
  //从而转换成一个I/O流，写入其他的地方
  //内存中的状态会被永久保存下来
  
  //反序列化就是将已经持久化的字节码内容转换为I/O流
  //通过I/O流的读取，进而将读取的内容转换成为Java对象
  //在转换过程中会重新创建对象
  public final static SeriableSingleton INSTANCE = new SeriableSingleton();
  private SeriableSingleton(){}
  
  public static SeriableSingleton getInstance(){
    return INSTANCE;
  }
}

客户端测试代码：

package com.design.pattern.singleton;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SeriableSingletonTest {
    public static void main(String[] args) {
        SeriableSingleton s1 = null;
        SeriableSingleton s2 = SeriableSingleton.getInstance();

        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("SeriableSingleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(s2);
            oos.flush();
            oos.close();

            FileInputStream fis = new FileInputStream("SeriableSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            s1 = (SeriableSingleton) ois.readObject();

            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s1 == s2);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

测试结果：

com.design.pattern.singleton.SeriableSingleton@7cd84586
com.design.pattern.singleton.SeriableSingleton@5a07e868
false

从运行结果可以知道，反序列化后的对象和手动创建的对象是不一致的，被实例化了两次，违背了单例模式的设计初衷。要想解决，其实增加一个readResolve（）方法即可：代码如下：

//反序列化破坏了单例模式
public class SeriableSingleton implements Serializable{
  //序列化就是把内存中的状态通过转换成字节码的形式
  //从而转换成一个I/O流，写入其他的地方
  //内存中的状态会被永久保存下来
  
  //反序列化就是将已经持久化的字节码内容转换为I/O流
  //通过I/O流的读取，进而将读取的内容转换成为Java对象
  //在转换过程中会重新创建对象
  public final static SeriableSingleton INSTANCE = new SeriableSingleton();
  private SeriableSingleton(){}
  
  public static SeriableSingleton getInstance(){
    return INSTANCE;
  }
  private Object readResolve(){
    return INSTANCE;
  }
}

结果如下：

com.design.pattern.singleton.SeriableSingleton@5a07e868
com.design.pattern.singleton.SeriableSingleton@5a07e868
true

从JDK源码来看，虽然增加readResolve()方法返回实例解决了单例模式被破坏的问题，但实际上单例对象被实例化了两次，只不过新创建的对象没有返回而已。

容器式单例写法：

public class ContainerSingleton{
  private ContainerSingleton(){}
  private static Map<String,Object> ioc = new ConcurrentHashMap<String,Object>();
 	public static Object getBean(String className){
    synchronized(ioc){
      if(!ioc.containsKey(className)){
        Object obj = null;
        try{
          obj = Class.forName(className).newInstance();
        }catch(Exception e){
          e.printStackTrace();
        }
        return obj;
      }else{
        return ioc.get(className);
      }
    }
  }
}

容器式单例写法适用于需要大量创建单例对象的场景，便于管理，但它是非线程安全的。

ThreadLocal单例详解

线程单例实现ThreadLocal，不能保证其创建的对象是全局唯一的，但能保证在单个线程中是唯一的，是线程安全的。看下面代码：

package com.design.pattern.singleton;

public class ThreadLocalSingleton {
    private static final ThreadLocal<ThreadLocalSingleton> threadLocalInstance =
            new ThreadLocal<ThreadLocalSingleton>(){
                @Override
                protected ThreadLocalSingleton initialValue() {
                    return new ThreadLocalSingleton();
                }
            };
    private ThreadLocalSingleton(){};
    
    public static ThreadLocalSingleton getInstance(){
        return threadLocalInstance.get();
    }
}

测试代码：

package com.design.pattern.singleton;

public class ThreadLocalSingletonTest {
    public static void main(String[] args) {
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println("-----------------");
        Thread t1 = new Thread(new ExectorThread());
        Thread t2 = new Thread(new ExectorThread());
        t1.start();
        t2.start();
    }
}

结果如下：

com.design.pattern.singleton.ThreadLocalSingleton@135fbaa4
com.design.pattern.singleton.ThreadLocalSingleton@135fbaa4
com.design.pattern.singleton.ThreadLocalSingleton@135fbaa4
com.design.pattern.singleton.ThreadLocalSingleton@135fbaa4
com.design.pattern.singleton.ThreadLocalSingleton@135fbaa4
-----------------
Thread-1:com.design.pattern.singleton.LazySingleton@33e329ce
Thread-0:com.design.pattern.singleton.LazySingleton@33e329ce

由测试可以知道，在主线程中无论调用多少次，获取的实例都是同一个，都在两个字线程中分别获取了不同的实例。我们知道单例模式为了达到线程安全的目的，会给方法上锁，以时间换空间。ThreadLocal将多有的对象放在ThreadLocalMap中，为每个线程都提供一个对象，实际上是以空间换时间来实现线程隔离的。

单例的优点：

  1. 单例模式可以保证内存里只有一个实例，减少了内存的开销

  2. 可以避免对资源的多重占用

  3. 单例模式设置全局访问点，可以优化和共享资源

单例模式缺点：

  1. 单例模式一般没有接口，扩展困难，如果要扩展，则出了修改原来的代码，没有第二种途径，违背开闭原则

  2. 在并发测试中，单例模式不利于代码的调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。

  3. 单例模式的功能代码通常写在一个类中，如果功能设计的不合理，则很容易违背单一职责原则

J_Newbie
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java设计模式之单例设计模式
小贺想改变
09-29 973
初步认识设计模式、23种设计模式简介下载、单例模式的初步认识、单例模式的饿汉式和懒汉式的实现
Java设计模式-单例设计模式
freelome的博客
04-02 98
设计模式之一：单例设计模式 单例设计模式 需要解决的问题：保证在一个软件系统中，对某个类只能存在一个对象实例。
java设计模式之单例设计模式
qq_45946517的博客
08-09 120
两种方式的不同点：饿汉式是在类加载时就创建了对象实例，懒汉式只有在使用时才会创建对象实例。
JAVA设计模式之单例模式
最新发布
09-22
单例模式是软件设计模式中的一种经典模式，它在Java编程中被广泛使用，尤其是在需要控制实例化过程，或者确保某类只有一个实例时。本文将深入探讨Java中的单例模式，帮助你理解其原理和应用。 单例模式的核心思想是...
Java设计模式之单例模式
12-22
　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的...
java 设计模式之单例模式
08-31
Java中的单例模式是一种设计模式，它用于控制类的实例化过程，确保在整个应用程序中，一个类只有一个实例存在。这在处理全局资源、缓存、线程池等场景时非常有用，因为它可以避免多个实例之间的数据冲突，节省系统...
全面解析Java设计模式之单例模式
08-28
单例模式是设计模式中的一种基础模式，它确保一个类在任何情况下只有一个实例存在。这种模式的核心在于限制类的实例化，保证全局范围内只有一个对象，同时也提供了一个全局访问点，使得其他部分的代码能够方便地使用...
Java设计模式 - 单例模式
探长々
08-25 390
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。单例类只能有一个实例。单例类必须自己创建自己的唯一实例。单例类必须给所有其他对象提供这一实例。在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）
JAVA设计模式--单例模式
JAVA_SR的博客
09-21 677
单例设计模式
java设计模式—单例模式
weixin_46972127的博客
04-18 316
目录 1、什么是设计模式？ 2、什么是单例模式？ 3、单例模式的具体实现方式 3.1 饿汉模式 3.2 懒汉模式 1、什么是设计模式？ 设计模式就好比象棋种的“棋谱”，红方当头炮，黑方马来跳。针对对方的一些招数，己方的一些固定套路。 2、什么是单例模式？ 单例模式是指在内存中只会创建且仅创建一次对象的设计模式。在程序中多次使用一个对象且作用相同时，为了防止频繁创建对象使得内存飙升，单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。实现方式：构造方法的
Java设计模式—单例模式（Singleton Pattern）
是个非常热爱生活、乐观、奋斗、努力的逗比青年
06-06 554
单例模式（Singleton Pattern）是一种创建型设计模式，一种非常非常常用的设计模式。它保证一个类仅有一个实例，并提供一个访问它的全局访问点；饿汉式：类加载时就创建了对象实例，因此线程安全，但会造成资源浪费；懒汉式：只有在需要时才创建对象实例，节省了系统资源，但需要考虑线程安全问题；双重校验锁：在懒汉式的基础上加入双重校验，保证了线程的安全且减少了锁的“竞争”；饿汉式：类加载时创建对象实例。懒汉式：只有在需要的时候才创建对象实例。
Java设计模式_单例设计模式详解
生活充满热情
09-08 202
/** * 单例设计模式：饿汉式，不适用于多线程，效率低 */ public class SingleTest { //定义一个私有的构造方法 private SingleTest() {} //将自身的实例对象设置成静态 final private static final SingleTest instance = new SingleTest()...
【Java】单例模式
王如霜
03-17 172
一：何时用单例模式 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;只实例化一个对象时。几乎所有的系统都会用到单例模式 二：模式 构造函数是私有的private 产生一个静态的私有的对象 写一个静态的公有的方法，返回该类类型的实例化对象 三：分类： 懒汉式 存在多线程同步问题，可能会存在多个ClientManager 实例对象 当类第一次被加载时，不会为...
设计模式-单例模式
鹈鹕门将的博客
04-27 262
一、单例模式概述 单例模式是结构最简单的设计模式。 如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个统一的·全局变量确保对象随时都可以被访问，但不能保证防止创建多个对象。一个更好的解决办法是让类自身负责创建和保存它的唯一实例，并保证不能创建其他实例，它还提供一个可以访问实例的方法，这就是到单例模式的动机。 单例模式定义：确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一实
JAVA学习----简单的Client/Server程序
weixin_64771061的博客
09-22 902
前端任务和后端任务对计算资源有着根本不同的要求，例如处理器速度，内存，磁盘速度和容量以。式简单地讲就是基于企业内部网络的应用系统，大部分的应用逻辑都集中在客户端中，而一般服务。水平扩展意味着添加或删除客户。统最大的好处是不依赖企业外网环境，即无论企业是否能够上网，都不影响应用。服务器体系结构，它是一种网络体系结构，其中客户端是用户运行应用程序的。结构）结构即浏览器和服务器结构，瘦客户端应用，主要逻辑集中在服。服务器）结构，胖客户端应用，是软件系统体系结构的一种。务器端，客户端一般只包含的简单的显示逻辑。
Java设计模式：单例模式详解与实现
"Java设计模式主要探讨了工厂模式、工厂方法模式、单例模式、外观模式、观察者模式和桥接模式。这些模式在不同项目中广泛应用，它们提供了灵活的解决方案来处理各种设计挑战。单例模式是其中的一个重要概念，确保一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值