Java Thread.interrupt 复习

高速设计注意事项总结——MDI篇 在以太网高速通信系统中,MDI(Medium Dependent Interface,介质相关接口)是连接物理层芯片(PHY)与传输介质(如网线)的关键接口,其设计直接影响信号完整性、传输速率和抗干扰能力。本文围绕 MDI 及 RJ45 接口电路、关键参数、设计与布线要点展开,为高速以太网设计提供参考。本文包含MDI 及 RJ45 接口电路组成、电路设计注意事项、布局布线要求等内容 阅读详情

本文转载自:Java Thread.interrupt[点击打开链接], 文章写的太好,怕丢了,所以原文也一并拷贝过来。

下面这个场景你可能很熟悉,我们调用Thread.sleep(),condition.await(),但是IDE提示我们有未捕获的InterruptedException。什么是InterruptedException呢?我们又应该怎么处理呢?

大部分人的回答是,吞掉这个异常就好啦。但是其实,这个异常往往带有重要的信息,可以让我们具备关闭应用时执行当前代码回收的能力。

Blocking Method

如果一个方法抛出InterruptedException(或者类似的),那么说明这个方法是一个阻塞方法。(非阻塞的方法需要你自己判断,阻塞方法只有通过异常才能反馈出这个东西)

当我们直接调用一个Unschedule的线程的interrupt方法的时候,会立即使得其变成schedule(这一点非常重要,由JVM保证), 并且interrupted状态位为true。

通常low-level method,像sleep和await这些方法就会在方法内部处理这个标志位。例如await就会在醒来之后检查是否有中断。所以在Sync内部通常在唤醒之后都会检查中断标志位。

看下面一段代码:

  public static void main(String[] args) {
        Thread a = new Thread(new Runnable() {
            @Override
            public void run() {
                long start = System.currentTimeMillis();
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    // what to do ?
                }
                System.out.println(System.currentTimeMillis() - start);
            }
        });
        a.start();
        // 加上这句话,执行时间是0,没有这句话执行时间是10,你感受下
        a.interrupt(); 
}

所以,当我们直接Interrupt一个线程的时候,他会立即变成可调度的状态,也就是会里面从阻塞函数中返回。这个时候我们拿到InterruptedException(或者在更底层看来只是一个线程中断标志位)的时候应该怎么做呢?

在low-level的层面来说,只有中断标志位,这一个概念,并没有interruptException,只是jdk的框架代码中,为了强制让客户端处理这种异常,所以在同步器、线程等阻塞方法中唤醒后自动检测了中断标志位,如果符合条件,则直接抛出受检异常。

How to Deal

Propagating InterruptedException to callers by not catching it

当你的方法调用一个blocking方法的时候,说明你这个方法也是一个blocking方法(大多数情况下)。这个时候你就需要对interruptException有一定的处理策略,通常情况下最简单的策略是把他抛出去。参考下面的代码:

参考blockingQueue的写法,底层使用condition对象,当await唤醒的时候有interruptException的时候,直接抛出,便于上层处理。换句话说,你的代码这个层面没有处理的必要和意义。

public class TaskQueue {
    private static final int MAX_TASKS = 1000;

    private BlockingQueue<Task> queue 
        = new LinkedBlockingQueue<Task>(MAX_TASKS);

    public void putTask(Task r) throws InterruptedException { 
        queue.put(r);
    }

    public Task getTask() throws InterruptedException { 
        return queue.take();
    }
}
Do some clean up before thrown out

有时候,在当前的代码层级上,抛出interruptException需要清理当前的类,清理完成后再把异常抛出去。下面的代码,表现的就是一个游戏匹配器的功能,首先等待玩家1,玩家2都到达之后开始游戏。如果当前玩家1到达了,线程接受到interrupt请求,那么释放玩家1,这样就不会有玩家丢失。

public class PlayerMatcher {
    private PlayerSource players;

    public PlayerMatcher(PlayerSource players) { 
        this.players = players; 
    }

    public void matchPlayers() throws InterruptedException { 
        Player playerOne, playerTwo;
         try {
             while (true) {
                 playerOne = playerTwo = null;
                 // Wait for two players to arrive and start a new game
                 playerOne = players.waitForPlayer(); // could throw IE
                 playerTwo = players.waitForPlayer(); // could throw IE
                 startNewGame(playerOne, playerTwo);
             }
         }
         catch (InterruptedException e) {  
             // If we got one player and were interrupted, put that player back
             if (playerOne != null)
                 players.addFirst(playerOne);
             // Then propagate the exception
             throw e;
         }
    }
}
Resorting Status

如果已经到了抛不出去的地步了,比如在Runnable中。当一个blocking-method抛出一个interruptException的时候,当前线程的中断标志位实际是已经被清除了的,如果我们这个时候不能再次抛出interruptException,我们就无法向上层表达中断的意义。这个时候只有重置中断状态。但是,这里面还是有很多技巧...不要瞎搞:

public class TaskRunner implements Runnable {
    private BlockingQueue<Task> queue;
    public TaskRunner(BlockingQueue<Task> queue) { 
        this.queue = queue; 
    }
    public void run() { 
        try {
             while (true) {
                 Task task = queue.take(10, TimeUnit.SECONDS);
                 task.execute();
             }
         } catch (InterruptedException e) { 
             // Restore the interrupted status
             Thread.currentThread().interrupt();
         }
    }
}

注意上面代码,catch异常的位置,在看下面一段代码

public class TaskRunner implements Runnable {
    private BlockingQueue<Task> queue;
    public TaskRunner(BlockingQueue<Task> queue) { 
        this.queue = queue; 
    }
    public void run() { 
       while (true) {
            try {
              Task task = queue.take(10, TimeUnit.SECONDS); 
              task.execute(); 
            } catch (InterruptedException e) { 
              Thread.currentThread().interrupt();
            }
        }
}

这段代码就会造成无限循环,catch住之后,设置中断标志,然后loop,take()函数立即抛出InterruptException。你感受下。

千万不要直接吞掉

当你不能抛出InterruptedException,不论你决定是否响应interrupt request,这个时候你都必须重置当前线程的interrupt标志位,因为interrupt标志位不是给你一个人看的,还有很多逻辑相应这个状态。标准的线程池(ThreadPoolExecutor)的Worker对象(内部类)其实也会对interrupt标识位响应,所以向一个task发出中断信号又两个作用,1是取消这个任务,2是告诉执行的Thread线程池正在关闭。如果一个task吞掉了中断请求,worker thread就不能响应中断请求,这可能导致application一直不能shutdown.

万不要直接吞掉
// Don't do this 
public class TaskRunner implements Runnable {
    private BlockingQueue<Task> queue;
    public TaskRunner(BlockingQueue<Task> queue) { 
        this.queue = queue; 
    }
    public void run() { 
        try {
             while (true) {
                 Task task = queue.take(10, TimeUnit.SECONDS);
                 task.execute();
             }
         }
         catch (InterruptedException swallowed) { 
             /* DON'T DO THIS - RESTORE THE INTERRUPTED STATUS INSTEAD */
         }
    }
}
Implementing cancelable tasks

从来没有任何文档给出interruption明确的语义,但是其实在大型程序中,中断可能只有一个语义:取消,因为别的语义实在是难以维持。举个例子,一个用户可以用通过GUI程序,或者通过一些网络机制例如JMX或者WebService来发出一个关闭请求。也可能是一段程序逻辑,再举个简单的例子,一个爬虫程序如果检测到磁盘满了,可能就会自行发出中断(取消)请求。或者一个并行算法可能会打开多个线程来搜索什么东西,当某个框架搜索到结果之后,就会发出中断(取消)请求。

一个task is cancelable并不意味着他必须立刻响应中断请求。如果一个task在loop中执行,一个典型的写法是在每次Loop中都检查中断标志位。可能循环时间会对响应时间造成一定的delay。你可以通过一些写法来提高中断的响应速度,例如blocking method里面往往第一行都是检查中断标志位。

Interrupts can be swallowed if you know the thread is about to exit 唯一可以吞掉interruptException的场景是,你明确知道线程就要退出了。这个场景往往出现在,调用中断方法是在你的类的内部,例如下面一段代码,而不是被某种框架中断。

public class PrimeProducer extends Thread {
    private final BlockingQueue<BigInteger> queue;
    PrimeProducer(BlockingQueue<BigInteger> queue) {
        this.queue = queue;
    }
    public void run() {
        try {
            BigInteger p = BigInteger.ONE;
            while (!Thread.currentThread().isInterrupted())
                queue.put(p = p.nextProbablePrime());
        } catch (InterruptedException consumed) {
            /* Allow thread to exit */
        }
    }
    public void cancel() { interrupt(); }
}
Non-Interruptible Blocking

并不是所有blockingMethod都支持中断。例如input/outputStream这两个类,他们就不会抛出InterruptedException,也不会因为中断而直接返回。在Socket I/O而言,如果线程A关闭了Socket,那么正在socket上读写数据的B、C、D都会抛出SocketException. 非阻塞I/O(java.nio)也不支持interruptiable I/O,但是blocking operation可以通过关闭channel或者调用selector.wakeUp方法来操作。类似的是,内部锁(Synchronized Block)也不能被中断,但是ReentrantLock是支持可被中断模式的。

Non-Cancelable Tasks

有一些task设计出来就是不接受中断请求,但是即便如此,这些task也需要restore中断状态,以便higher-level的程序能够在这个task执行完毕后响应中断请求。

下面这段代码就是一个BlockingQueue.poll()忽略中断的的例子(和上面我的备注一样,不要在catch里面直接restore状态,不然queue.take()会造成无限循环。

public Task getNextTask(BlockingQueue<Task> queue) {
    boolean interrupted = false;
    try {
        while (true) {
            try {
                return queue.take();
            } catch (InterruptedException e) {
                interrupted = true;
                // fall through and retry
            }
        }
    } finally {
        if (interrupted)
            Thread.currentThread().interrupt();
    }
}

Summary

你可以利用interruption mechanism来提供一个灵活的取消策略。任务可以自行决定他们是否可以取消,或者如何响应中断请求,或者处理一些task relative cleanup。即便你想要忽略中断请求,你也需要restore中断状态,当你catchInterruptedException的时候,当higher不认识他的时候,就不要抛出啦。

如果你的代码在框架(包括JDK框架)中运行,那么interruptException你就务必像上面一样处理。如果单纯的你自己的小代码片段,那么你可以简单地认为InterruptException就是个bug。

在生产环境下,tomcat shutdown的时候,也会大量关闭线程池,发出中断请求。这个时候如果响应时间过于慢就会导致tomcat shutdown非常的慢(甚至于不响应)。所以大部分公司的重启脚本中都含有重启超时(例如20s)的一个强杀(kill -9)的兜底策略,这个过程对于程序来说就等于物理上的断电,凡是不可重试,没有断电保护,业务不幂等的情况都会产生大量的数据错误。

就现在业内的做法而言,大部分上述描述的问题几乎已经不再通过interrupt这种关闭策略来解决(因为实在难以解决),转而通过整体的系统架构模型来规避数据问题,例如数据库事务,例如可重试的幂等任务等等。

针对前端用户而言,就是ng的上下线心跳切换。但即使如此,对于请求已经进入tomcat线程池中的前端用户而言,还是会存在极其少量的服务器繁忙:)

AI 大模型应用数据中心的数据清洗工具 1. 背景介绍 在人工智能大模型应用的浪潮中,数据清洗作为数据预处理的重要环节,对于提升模型性能和可靠性具有至关重要的作用。数据中心作为人工智能模型的运行环境,面临着海量数据流和多样化的数据类型,如何高效、准确地进行数据清洗,成为应用大模型的关键问题之一。本文将详细介绍AI大模型应用数据中心的数据清洗工具,包括核心概念、算法原理、具体操作步骤、应用场 阅读详情

相关推荐

模拟CMOS 第2章 MOS器件物理基础

模拟CMOS 第2章 MOS器件物理基础 文章目录模拟CMOS 第2章 MOS器件物理基础2.1 基本概念2.1.1 MOSEFT开关2.1.2 MOSEFT结构2.1.3 MOS符号2.2 MOS的I/V特性2.2.1 阈值电压2.2.2 I/V特性的推导2.3 二级效应2.4 MOS器件模型2.4.1 MOS器件版图2.4.2 MOS器件电容2.4.3 MOS小信号模型2.4.4 MOS SPICE模型2.4.5 NMOS与PMOS器件的比较2.4.6 长沟道器件与短沟道器件的比较附录A 用作电容器MO

椰子奶糖的博客 5209

Java Thread.interrupt interrupted

Java Thread.interrupt @(Base)[JDK, 线程, interrupt] 原文地址,转载请注明 下面这个场景你可能很熟悉,我们调用Thread.sleep(),condition.await(),但是IDE提示我们有未捕获的InterruptedException。什么是InterruptedException呢?我们又应该怎么处理呢? 大部分人的回答是,吞掉这个异常就好...

weixin_34061042的博客 133

Proteus下载安装快速入门:30分钟掌握全过程

手把手教你完成proteus下载安装,从环境配置到首次运行一气呵成,适合电子设计新手快速掌握仿真工具的核心操作步骤。

weixin_31974443的博客 896

[bugfix]重新理解Thread的InterruptedException

在前面一篇blog中,错误理解了中断异常,还被评为新手贴,最近找时间认真理解了一下线程的这个异常,呵呵。: 原文在这里。   下文部分内容来自dw上的一篇文章,已经贴在附件里面、。   下面通过一段代码来演示中断:   package thread; /** * created on 2010-4-27下午04:32:40 * * @author weisong ...

wei 287

Educoder | 计算机网络实验-Ping命令与ICMP协议分析

任务描述本关任务:捕获 Ping 程序生成的数据包。相关知识ping命令Ping 程序是一个简单的工具,允许任何人(例如:网络管理员)验证主机是否存在。源主机中的 Ping 程序将数据包发送到目标 IP 地址;如果目标是在线的,则目标主机中的 Ping 程序将会发送响应 Ping 数据包证明他在线,这两个 Ping 数据包都是 ICMP 数据包。在 Unix/Linux,序列号从 0 开始计数,依次递增。而 Windows 中 ping 程序的 ICMP 序列号是没有规律;;。

Mksg_28的博客 7638

用OpenNI2获取奥比中光Astra Pro及 Astra Pro SM输出的深度图(win,linux arm64 x64平台)

搞了一个奥比中光Astra Pro,想在windows平台,和linux rk3588 上获取深度信息,之前的驱动下载已经不好用了。

babytiger的专栏 1309

Thread的中断机制(interrupt)

先看收集了别人的文章,全面的了解下java的中断: 中断线程 线程的thread.interrupt()方法是中断线程,将会设置该线程的中断状态位,即设置为true,中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步,就取决于这个程序本身。线程会不时地检测这个中断标示位,以判断线程是否应该被中断(中断标示值是否为true)。它并不像stop方法那样会中断一个正在运行的线程。 判断线程...

weixin_30505225的博客 2672

DSH-Work:一个让DeepSeek下载即用的Harness客户端

使用大模型工具时,环境配置往往比模型本身更让人头疼。DeepSeek Harness作为一类封装层,将模型调用、上下文管理、参数控制等复杂细节统一收拢,对外提供简洁操作入口。开源的DSH-Work正是这样一款Harness客户端,它通过自带运行时与保守默认配置,实现了下载即用、免配环境的目标,让使用者无需掌握Python、CUDA等专业知识即可快速连接DeepSeek云端或本地服务。对于非技术背景的用户,它降低了AI工具的使用门槛;对于开发者,它把时间从环境排错中解放出来,更专注于提示词调优与工作流设计。无

weixin_29048309的博客 347

线程中断Thread的interrupt()方法

什么时候需要关闭一个线程? 下面简单的举例情况: 比如我们会启动多个线程做同一件事,比如抢12306的火车票,我们可能开启多个线程从多个渠道买火车票,只要有一个渠道买到了,我们会通知取消其他渠道。这个时候需要关闭其他线程 很多线程的运行模式是死循环,比如在生产者/消费者模式中,消费者主体就是一个死循环,它不停的从队列中接受任务,执行任务,在停止程序时,我们需要一种”优雅”的方法以关闭该线程 在一些场景中,比如从第三方服务器查询一个结果,我们希望在限定的时间内得到结果,如果得不到,我们会希望取消该任务

weixin_42352733的博客 1万+

电气论文实现:前推回代在IEEE33节点中的潮流计算实现(matlab,python)

本文首先介绍了前推回代的原理。然后基于IEEE33节点算例,分别用python和matlab运用前推回代进行了潮流计算。

总裁余(余登武)博客 8613

YOLOv8架构革命:通过EfficientViT融合实现精度-速度的帕累托突破

目标检测领域长期存在精度与速度的权衡难题。视觉Transformer(ViT)的引入解决了长距离依赖问题,但其巨大的计算复杂度制约了实时应用。最新研究表明,将轻量级ViT与YOLO架构融合,可在几乎不损失推理速度的前提下,将mAP提升3-8个百分点。这种架构改进方案已在工业检测、自动驾驶、安防监控等多个领域得到验证,在保持实时性的同时显著提升了复杂场景下的检测可靠性。通过模块化设计,可以灵活适配不同规模的YOLOv8模型,为实际应用提供精度-速度的帕累托最优解。

FJN110的博客 149

Java面试必看!如何优雅唤醒阻塞线程?

《Java面试必看!如何优雅唤醒阻塞线程?》:线程阻塞是多线程编程中的常见问题,本文从实际案例出发,深入讲解如何通过interrupt()、wait/notify机制及CompletableFuture等方法优雅唤醒阻塞线程。特别针对面试中常被忽视的细节,如中断标志位处理和异常抛出机制,提供清晰解决方案,并附带代码示例,助你轻松应对线程相关问题,避免因技...

yanpeng2580的博客 409

YOLOv8改进-bifpn

跨尺度连接通过添加一个跳跃连接和双向路径来实现,自此实现了加权融合和双向跨尺度连接。该结构是加权且双向连接的,即自顶向下和自底向上结构,通过构造双向通道实现跨尺度连接,将特征提取网络中的特征直接与自下而上路径中的相对大小特征融合,保留了更浅的语义信息,而不会丢失太多的深层语义信息。传统的特征融合时将尺度不同的特征图以相同权重进行加权,但是当输入的特征图分辨率不同时,以相同的权重进行加权对输出的特征图不平等。所以BiFPN根据不同输入特征的重要性设置不同的权重,同时反复采用这种结构来加强特征融合。

weixin_45303602的博客 8139

java中断一个正在运行中的线程

java中断一个正在运行中的线程

秋叶清风的博客 272

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

关于对 JUC 的 Interrupt 和 Interrupted 方法的一些理解

在讲到中断方法之前,我们先谈谈什么是线程中断。在Java并发编程中,线程中断是一种协作机制,允许一个线程向另一个线程发出停止正在进行的操作的请求通知。这种通知是通过设置所谓的“中断状态”来实现的。但重要的是,线程中断不是强迫线程停止,而是给线程一个机会来优雅地结束它的执行。这个“机会”实际上是在告诉线程:“你可以继续进行,但有一个请求建议你在下一个合适的时刻停下来。”线程可以检查这个请求(即中断状态),然后决定是否以及何时响应。

weixin_59736343的博客 2204

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

浅谈Thread类及常见方法与线程的状态(多线程编程篇2)

如何简单的去使用jconsloe 查看线程 (多线程编程篇1)_如何查看weblogic当前线程-优快云博客距离笔者发布本系列第一篇博客已过去一月有余,本篇博客,笔者将继续介绍已经整理学习好的内容既帮助未来的自己复习,也为正在阅读的你提供参考和思考.本篇博客的内容正如标题所示,笔者主要将介绍一下内容1.Thread类,并通过举例演示常见方法2.向大家介绍线程的状态.愿我们一起进步!

cjejwe的博客 2064

Java基础复习——Thread

一、基本概念:               线程:指运行中的程序的调度单位,通俗说是一个程序执行路径。           进程:进程就是一段程序的执行过程,一个静态的概念。   二、启动和创建线程的方法: Java多线程实现方法两种:1.实现Runnable接口2.继承自Thread类。代码如下:  1.实现Runnable接口 public T implements Runn

HackerSaillen的专栏 1279

Java的多线程——多线程(二)Thread

多线程的学习

HANhylyxy的博客 809

软件构造复习(4) - 并发和线程安全

一、并发 1.创建线程的几种方式 1.1 继承Thread类创建线程 //继承Thread类 public class HelloThread extends Thread{ //重写run方法即可 public void run() { System.out.println("Hello from a thread!"); } public static void main(String args[]) { HelloThread p = new HelloThread();

weixin_45406155的博客 307

Java基础面试题(07)—Java(线程)

本文介绍了Java线程的基础知识,包括线程的概念、创建方式及常用方法。线程是进程中的执行单元,共享进程资源但拥有独立栈空间。Java提供了三种创建线程的方法:继承Thread类、实现Runnable接口和实现Callable接口。文章通过代码示例详细展示了每种方法的实现,并分析了它们的优缺点。此外,还列举了线程的常用方法如start()、run()、sleep()等,帮助开发者掌握线程的基本操作。最后提醒开发者学习技术时应注重思考而非简单复制,为后续学习和面试做好准备。

2301_81189772的博客 871

警惕jdk8 UDP和Thread.interrupt的Bug

线上业务在热点流量大的情况下(业务采用Java编程语言实现),单机偶发出现Hystrix熔断,接口无法提供服务。

bd7xzz 2019

警惕 JDK8 UDP 和 Thread.interrupt 的 Bug

在DatagramChannelImpl.send 方法中会拿到两把锁,注意其中一把为 stateLock,即线程中的 - locked (a java.lang.Object)。1. 在 Thread.interrupt 方法中会调用 b.interrupt,注意这里会拿到 blokcerLock,即线程栈中的 - locked (a java.lang.Object)。所以,要么升级 JDK 到 13,要么死!

m0_46163918的博客 440

Java多线程与并发初步理解

前言:这是在慕课网上学习剑指Java面试-Offer直通车时所做的笔记,主要供本人复习之用. 目录 第一章 进程和线程的区别 1.1 进程和线程的由来 1.2 进程与线程的区别 1.3 Java进程和线程的关系 1.4 证明java程序存在主线程 第二章 Thread中start和run方法的区别 2.1 实际现象 2.2 源码分析 第三章 Thread和Runnable是什么...

仰望星空 565

java线程复习3(线程的中断)

package MyThread.Test3; import org.omg.PortableInterceptor.SYSTEM_EXCEPTION; /* * Create by dapeng on 2018/2/2 */ public class PrimeGenerator extends Thread { @Override pub...

aichuangen8612的博客 117

JavaEE初阶 | Thread类基本用法总结

多线程是 Java 开发核心内容,是线程的核心类,所有线程操作都依托该类完成。本文整理日常开发最常用的四大核心操作:线程创建、线程休眠、线程等待、线程中断。同时讲解如何获取当前线程实例,附带可运行代码与底层原理,适合初学者复习、面试背诵。线程创建优先使用 Runnable+Lambda,杜绝继承 Thread;sleep () 静态休眠,阻塞不释放锁,会响应中断异常;join () 控制线程执行顺序,主线程等待子线程完成;interrupt () 仅打标记,不会强制终止线程,需代码配合退出;

shineJerome的博客 212

java复习-线程常用操作方法

强制执行:当满足于某些条件之后,某一个线程对象将可以一直独占资源,一直到该线程的程序执行结束。

A Lonely Potatoe 273

多线程状态-复习

1.创建 创建有两种方式:1继承Thread,2实现Runnable。其实继承Thread,也会实现Runbable。 new Thread去建立一个线程,线程的资源是new Thread中传入的对象。 2.状态 线程的状态有NEW , RUNNABLE , WAITING , TING_WAITING ,BLOCKED, TERMINATED 问题:NEW时初始化了线程的名称,资源;还没...

罗兰娇的博客 154
上一篇: 一种重置生产者消费者模式的消费队列的线程安全的做法(java)
下一篇: 同时使用java和scala语言的maven项目pom文件示例
lhever_
博客等级 码龄14年 213粉丝 130原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值