并发Goroute、定时器、信号处理、单元测试

最新推荐文章于 2025-08-27 23:30:00 发布
转载 最新推荐文章于 2025-08-27 23:30:00 发布 · 156 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/domestique/p/8410313.html

本文深入探讨Goroutine的概念及其实现原理，并详细讲解Channel的使用方式与特性，包括其在多线程环境中如何帮助实现高效的数据交换。

Goroutine(轻量级的线程，开线程没有数量限制)

1.进程和线程
　　A.进程是程序在操作系统中的一次执行过程，系统进行资源分配和调度的一个独立单位。
　　B.线程是进程的一个执行实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。
　　C.一个进程可以创建和撤销多个线程；同一个进程中的多个线程之间可以并发执行。

2、进程和线程

　　ngix是多进程的单线程程序

 3.并发和并行
 　　A.多线程程序在一个核的cpu上运行，就是并发。go多线程的切换都是在用户态操作的，不像其他语言先切换到内核态，完成线程切换，然后返回用户态继续执行程序。
 　　B.多线程程序在多个核的cpu上运行，就是并行

4.协程和线程
　　协程：独立的栈空间，共享堆空间，调度由用户自己控制，本质上有点类似于用户级线程，这些用户级线程的调度也是自己实现的
　　线程：一个线程上可以跑多个协程，协程是轻量量级的线程。一个线程可以跑多个Goroutine。

5.goroutine调度模型

　M是物理线程，P是资源，G是Goroutine

 

如果有IO操作时，会新起一个线程等待IO操作的Goroutine

 

6.如何设置golang运行的cpu核数

　　1.5之前go需要手动设置程序执行的内核数，1.5之后go自动设置

package main

import (
    "fmt"
    "runtime"
)

func main() {
    num := runtime.NumCPU()  //查看有几个内核
    fmt.Printf("cpu num:%d\n", num) 
    runtime.GOMAXPROCS(1)    //设置有程序用几个内核执行
}

7、不同goroutine之间进行通讯　　

　　a.全局变量

package main

import (
    "fmt"
    "time"
)

var exits [3]bool

func calc(index int) {
    for i := 0; i < 1000; i++ {
        time.Sleep(time.Millisecond) //休息1毫秒
    }
    exits[index] = true
}

func main() {
    start := time.Now().UnixNano()
    go calc(0) //起一个goroutine，不用go就是串行
    go calc(1)
    go calc(2)

    for { //保证主线程不挂断，子线程才能执行
        if exits[0] && exits[1] && exits[2] {
            break
        }
        time.Sleep(time.Millisecond)
    }
    end := time.Now().UnixNano()
    fmt.Printf("finished, cost:%d ms\n", (end-start)/1000/1000)
}
View Code

　　b.锁同步

package main

import (
    "fmt"
    "sync"
    "time"
)

func calc(index int, waitGroup *sync.WaitGroup) {
    for i := 0; i < 1000; i++ {
        time.Sleep(time.Millisecond)
    }

    waitGroup.Done() //释放一把锁
}

func main() {
    var waitGroup sync.WaitGroup //等待一组Goroutine执行完毕
    start := time.Now().UnixNano()
    for i := 0; i < 3; i++ {
        waitGroup.Add(1) //添加一把锁
        go calc(i, &waitGroup)
    }

    waitGroup.Wait()
    end := time.Now().UnixNano()
    fmt.Printf("finished, cost:%d ms\n", (end-start)/1000/1000)
}
View Code

　　c.Channel(oroutine和channel相结合)

package main

import (
    "fmt"
    "time"
)


func () {
    var intChan chan int = make(chan int, 1) //如果是0就是没有缓冲区的管道，必须有程序来取才能放进去
    go func() {
        intChan <- 10
    }()

    result := <-intChan
    fmt.Printf("result:%d\n", result)
}
View Code

 8.goroutine中使用recover

应用场景，如果某个goroutine panic了，而且这个goroutine 里面没有捕获(recover)，那么整个进程就会挂掉。所以，好的习惯是每当go产生一个goroutine，就需要写下recover。

package main

import (
    "fmt"
    "time"
)

func calc() {

    defer func() { //defer必须放置在最前面，才能捕获后面所有的panic，程序退出时执行defer
        err := recover() //捕获goroutine错误
        if err != nil {
            fmt.Println(err)
        }
    }()

    var p *int
    *p = 100
}

func main() {
    go calc()
    time.Sleep(time.Second * 3)
    fmt.Println("progress exited")
}
View Code

 

Channel

1、channel概念 

  • 类似unix中管道（pipe） 
  • 先进先出
  • 线程安全，多个goroutine同时访问，不需要加锁
  • channel是有类型的， 一个整数的channel只能存放整数

2、 channel声明 

　　var 变量量名 chan 类型 

　　var test chan int 

　　var test chan string 

　　var test chan map[string]string 

　　var test chan stu

3、channel初始化

　　使用make进行初始化，比如： 

　　var test chan int

　　test = make(chan int, 10) 

　　var test chan string

　　test = make(chan string, 10)

4、channel基本操作

1. 从channel读取数据:

var testChan chan int

testChan = make(chan int, 10)

var a int

a = <- testChan

2. 从channel写 入数据:

var testChan chan int

testChan = make(chan int, 10)

var a int = 10

testChan <- a

5.带缓冲区的channel
 　　1.如下所示，testChan只能放 一个元素：
  　　　　var testChan chan int
  　　　　testChan = make(chan int)
  　　　　var a int
 　　　　 a = <- testChan
 　　2.如下所示，testChan是带缓冲区的chan， 一次可以放10个元素:
 　　 　　var testChan chan int
  　　　　testChan = make(chan int, 10)
 　　　　 var a int = 10
 　　　　 testChan <- a

package main

import (
    "fmt"
    "time"
)

func test() {
    var intChan chan int = make(chan int, 1) //如果是0就是没有缓冲区的管道，必须有程序来取才能放进去
    go func() {
        intChan <- 10
    }()

    result := <-intChan
    fmt.Printf("result:%d\n", result)
}

func testNoBufChan() {

    var intChan chan int = make(chan int, 2)
    go func() {

        fmt.Printf("begin input to chan\n")
        intChan <- 10
        intChan <- 10
        fmt.Printf("end input to chan\n")
    }()

    //result := <- intChan
    //fmt.Printf("result:%d\n", result)
    time.Sleep(10 * time.Second)
}

func main() {
    test()
    testNoBufChan()
}
View Code
package main

import (
    "fmt"
    "sync"
)

var waitGroup sync.WaitGroup

func produce(ch chan<- string) { //生产者
    ch <- "hello1"
    ch <- "hello2"
    ch <- "hello3"

    close(ch) //关闭管道
    waitGroup.Done()
}

func consume(ch <-chan string) { //消费者

    for {

        str, ok := <-ch //判断管道是否关闭
        if !ok {
            fmt.Printf("ch is closed")
            break
        }
        fmt.Printf("value:%s\n", str)
    }
    waitGroup.Done()
}

func main() {
    //生产者消费者模型
    var ch chan string = make(chan string)
    waitGroup.Add(2)
    go produce(ch)
    go consume(ch)
    waitGroup.Wait()
}
生产者消费者模型

 6. channel阻塞

package main

import (
    "fmt"
    "time"
)

func sendData(ch chan string) {
    var i int
    for {
        var str string
        str = fmt.Sprintf("stu %d", i)
        fmt.Println("write:", str)
        ch <- str
        i++
    }
}

func main() {
    ch := make(chan string)
    go sendData(ch)
    time.Sleep(100 * time.Second)
}
channel阻塞

7.chan之间的同步

package main

import (
    "fmt"
    "time"
)

func sendData(ch chan string) {
    ch <- "Washington"
    ch <- "Tripoli"
    ch <- "London"
    ch <- "Beijing"
    ch <- "Tokio"
}


func getData(ch chan string) {
    var input string
    for {
        input = <-ch
        fmt.Println(input)
    }
}


func main() {
    ch := make(chan string)
    go sendData(ch)
    go getData(ch)
    time.Sleep(100 * time.Second)
}
View Code

8.for range遍历chan

package main

import (
    "fmt"
    "time"
)

func sendData(ch chan string) {
    ch <- "Washington"
    ch <- "Tripoli"
    ch <- "London"
    ch <- "Beijing"
    ch <- "Tokio"
}

func getData(ch chan string) {
    for input := range ch {
        fmt.Println(input)
    }
}

func main() {
    ch := make(chan string)
    go sendData(ch)
    go getData(ch)
    time.Sleep(100 * time.Second)
}
View Code

9.chan的关闭  

　　1.使用内置函数close进行关闭，chan关闭之后，for range遍历chan中已经存在的元素后结束  

　　2.使用内置函数close进行关闭，chan关闭之后，没有使用for range的写法需要使用，v, ok := <- ch进行判断chan是否关闭 

10.chan的只读和只写  

　　a.只读chan的声明   

　　　　Var 变量量的名字 <-chan int   

　　　　Var readChan <- chan int

 　  b.只写chan的声明   

　　　　Var 变量量的名字 chan<- int   

　　　　Var writeChan chan<- int

11. 对chan进行select操作
 　　Select {
  　  　　case u := <- ch1:
  　　     case e := <- ch2:
  　　     default: 
　　 }

定时器 

1、定时器的使用

package main
import (
    "fmt"
    "time"
)


func main() {
    t := time.NewTicker(time.Second)
    for v := range t.C {
        fmt.Println("hello, ", v)
    }
}
View Code

2、一次定时器

package main

import (
    "fmt"
    "time"
)


func main() {
    select {
        Case <- time.After(time.Second):
        fmt.Println(“after”)
    }
}
View Code

3、超时控制

package main
import (
    "fmt"
    "time"
)
func queryDb(ch chan int) {
    time.Sleep(time.Second)
    ch <- 100
}
func main() {
    ch := make(chan int)

    go queryDb(ch)
    t := time.NewTicker(time.Second)
    select {
        case v := <-ch:
        fmt.Println("result", v)
        case <-t.C:
        fmt.Println("timeout")
    }
}
View Code

 

信号处理

package main

import (
    "fmt"
    "os"
    "os/signal"
    "sync"
    "syscall"
)

var waitGroup sync.WaitGroup

func produce(ch chan<- string, exitChan chan bool) {

    var i int
    var exit bool
    for {
        str := fmt.Sprintf("hello %d", i)
        select { //select检测哪个管道可写或者可读
        case ch <- str:
        case exit = <-exitChan:
        }
        if exit {
            fmt.Printf("user notify produce exited\n")
            break
        }
    }
    close(ch)
    waitGroup.Done()
}

func consume(ch <-chan string) {

    for {
        str, ok := <-ch
        if !ok {
            fmt.Printf("ch is closed")
            break
        }
        fmt.Printf("value:%s\n", str)
    }
    waitGroup.Done()
}

func main() {
    // 在shell终端输入 kill -SIGUSR2 ID   给程序输入终止信号
    var ch chan string = make(chan string)
    var exitChan chan bool = make(chan bool, 1)
    var sinalChan chan os.Signal = make(chan os.Signal, 1)
    waitGroup.Add(2)
    signal.Notify(sinalChan, syscall.SIGUSR2)
    go produce(ch, exitChan)
    go consume(ch)

    <-sinalChan //读取然丢弃
    exitChan <- true
    waitGroup.Wait()

}
信号处理

单元测试

1.文件名必须以_test.go结尾
2.使用go test -v执行单元测试

calc.go

package test

//对函数进行单元测试
func add(a int, b int) int {
    return a - b
}

func sub(a int, b int) int {
    return a - b
}
View Code

calc_test.go

package test

import (
    "testing"
)

func TestAdd(t *testing.T) { //TestAdd必须大写的Test开头
    result := add(2, 8) //测试add函数
    if result != 10 {
        t.Fatalf("add is not right") //致命错误记录
        return
    }

    t.Logf("add is right") //记录一些常规信息
}

func TestSub(t *testing.T) {
    result := sub(2, 8)
    if result != -6 {
        t.Fatalf("add is not right")
        return
    }

    t.Logf("add is right")
}
View Code

 

 

 

 

 

 

 

转载于:https://www.cnblogs.com/domestique/p/8410313.html

小白多久可以学会python?
lmseo5hy的博客
08-10 5141
众所周知，Python是一门简单易学的编程语言，很多零基础的人员均可轻松入门，但是想要精通，还是需要下一番苦功的。 Python学习这件事，想要做好，一方面靠自己，认真努力去学习，另一方面靠老师，好的老师掌握好的学习方法，让学习更轻松，知识更深入，能够轻松掌握高深技能！ 老男孩教育是Python培训领域的专家，2012年就开展了Python培训，是行业较早的Python培训机构，积累了大量的P...
HCIA-IoT V2.5 华为物联网认证笔记
weixin_57901967的博客
01-17 7297
文章目录1 华为物联网解决方案1.1 1个OS、2类接入、1个平台（1+2+1）1.2 华为云物联网平台架构1.3 NB-IoT端到端解决方案1.4 终端网关1.5 物联网操作系统 Huawei LiteOS1.6 物联网安全2 物联网通信技术2.1 有线RS-232与RS-485Meter-Bus有线通信技术简要对比2.2 无线短距无线蜂窝通信LPWA（Low Power Wide Area)无线通信技术对比2.3 NB-IoT技术及解决方案（重点）2.3.1 NB-IOT商用情况2.3.2 NB-IoT
软件测试精华总结，入门到精通全流程（必看，知识点很全）
公众号已改名为-程序员阿沐
03-01 6712
软件测试精华总结，入门到精通全流程（必看，知识点很全）
软件测试入门全流程精华总结【必看 知识点很全】
qq_15706073的博客
03-24 4158
软件测试基础 软件测试的概念 通过一系列手段去证明软件是符合用户需求的，满足质量要求的。预期结果和实际结果的一个对比。 软件测试分类 按方法分：黑盒测试、白盒测试、灰盒测试 黑盒测试：把软件比作一个“黑匣子”，不考虑具体是内部是如何实现的，只考虑外部功能的运行，检查软件的输入和输出是否匹配。 白盒测试：检查软件的代码、函数和方法等内部结构。 灰盒测试：介于白盒和灰盒测试之间，既可以根据外部暴露出的功能进行检测，也可以参考内部的代码结构。 2.按方向分：功能测试、性能测
《Java 并发编程实战》--读书笔记
回归心灵的专栏
12-10 1571
学习攻略 | 如何才能学好并发编程？ 注： 极客时间《Java 并发编程实战》–读书笔记 GitHub：https://github.com/ByrsH/Reading-notes/blob/master/Concurrency/Java并发编程实战-极客时间.md 并发编程领域抽象成三个核心问题：分工，同步和互斥。 分工：把一个功能分给不同的线程共同实现 同步：当某个条件不满足时，线程需要等待，...
uvloop深度实践：从原理到高性能异步应用实战
AI浩
08-27 1899
uvloop是Python异步编程的高性能事件循环库，基于libuv实现，可显著提升asyncio性能。相比标准asyncio，uvloop能将HTTP吞吐量提升375%，WebSocket连接数提升312%，同时降低47%的CPU使用率。安装简便，兼容Python 3.7-3.11，完全兼容asyncio接口，无需修改代码即可获得2-5倍的性能提升。测试显示，uvloop处理10,000个并发任务比标准循环快55%，是构建高性能异步应用的理想选择。
Go语言语法说明
weixin_30252709的博客
12-20 190
Go语言语法说明 go语言中的go func(){}() 表示以并发的方式调用匿名函数func 深入讲解Go语言中函数new与make的使用和区别 前言 本文主要给大家介绍了Go语言中函数new与make的使用和区别，关于Go语言中new和make是内建的两个函数，主要用来创建分配类型内存。在我们定义生成变量的时候，可能会觉得有点迷惑，其实他们的规则很简单，下面我们就通过一些...
socket通信和异常处理札记
lh2016rocky的博客
04-28 1万+
Linux socket通信出现CLOSE_WAIT状态的原因与解决方法 这个问题之前没有怎么留意过，是最近在面试过程中遇到的一个问题，面了两家公司，两家公司竟然都面到到了这个问题，不得不使我开始关注这个问题。说起CLOSE_WAIT状态，如果不知道的话，还是先瞧一下TCP的状态转移图吧。 关闭socket分为主动关闭（Active closure）和被动关闭（
关于Go语言的底层，你想知道的都在这里！
夏沫の梦的博客
03-09 1627
Go语言提供了一种机制在运行时更新和检查变量的值、调用变量的方法和变量支持的内在操作，但是在编译时并不知道这些变量的具体类型，这种机制被称为反射。反射也可以让我们将类型本身作为第一类的值类型处理。反射是指在程序运行期对程序本身进行访问和修改的能力，程序在编译时变量被转换为内存地址，变量名不会被编译器写入到可执行部分，在运行程序时程序无法获取自身的信息。
android高级面试题（二）
影子
05-06 1万+
Android高级面试题 （⭐⭐⭐） 一、性能优化 1、做过哪些性能优化？是怎么评测和具体优化的？ 一、App启动速度优化 开放问题：如果提高启动速度，设计一个延迟加载框架或者sdk的方法和注意的问题 二、App绘制优化 三、App内存优化 内存抖动（代码注意事项）： 内存抖动是由于短时间内有大量对象进出新生区导致的，它伴随着频繁的GC，gc会大量占用ui线程和cpu资...
go技术文章精选（2019）
热门推荐
韩亚军的博客
01-03 13万+
gocn_news_set_2019 gocn_news_2019-12-31 Go 系列教程：https://dev.to/digitalocean/how-to-code-in-go-32p0 Go modules：最小版本选择 https://tonybai.com/2019/12/21/go-modules-minimal-version-selection/ 部署服...
python神经网络编程 代码,python神经网络编程 豆瓣
aifamao6的博客
08-20 1135
segmentfault：一家以编程问答为主的网站;下面是Python全栈开发+人工智能的培训内容：阶段一：Python开发基础Python全栈开发与人工智能之Python开发基础知识学习内容包括：Python基础语法、数据类型、字符编码、文件操作、函数、装饰器、迭代器、内置方法、常用模块等。阶段二：Python高级编程和数据库开发Python全栈开发与人工智能之Python高级编程和数据库开发知识学习内容包括：面向对象开发、Socket网络编程、线程、进程、队列、IO多路模型、Mysql数据库开发等。
Rust：Restful API 服务程序开发详述
程序猿视角
09-03 2116
hyper库提供了低级别的HTTP/1和HTTP/2协议支持，可以用于构建高性能的HTTP客户端和服务器。它利用Rust的类型系统来确保代码的正确性，并与Rust的异步生态系统无缝集成，支持异步非阻塞I/O。Warp 建立在 hyper 和 Tokio 这两个异步 Rust 运行时之上，因此它自动继承了 HTTP/1 和 HTTP/2 支持、异步功能以及 hyper 被认为是最快之一的 HTTP 实现。
优化算法基于四则运算的算术优化算法原理与Python实现：面向图像分割的全局寻优方法研究
最新发布
09-06
内容概要：本文系统介绍了算术优化算法（AOA）的基本原理、核心思想及Python实现方法，并通过图像分割的实际案例展示了其应用价值。AOA是一种基于种群的元启发式算法，其核心思想来源于四则运算，利用乘除运算进行全局勘探，加减运算进行局部开发，通过数学优化器加速函数（MOA）和数学优化概率（MOP）动态控制搜索过程，在全局探索与局部开发之间实现平衡。文章详细解析了算法的初始化、勘探与开发阶段的更新策略，并提供了完整的Python代码实现，结合Rastrigin函数进行测试验证。进一步地，以Flask框架搭建前后端分离系统，将AOA应用于图像分割任务，展示了其在实际工程中的可行性与高效性。最后，通过收敛速度、寻优精度等指标评估算法性能，并提出自适应参数调整、模型优化和并行计算等改进策略。; 适合人群：具备一定Python编程基础和优化算法基础知识的高校学生、科研人员及工程技术人员，尤其适合从事人工智能、图像处理、智能优化等领域的从业者；; 使用场景及目标：①理解元启发式算法的设计思想与实现机制；②掌握AOA在函数优化、图像分割等实际问题中的建模与求解方法；③学习如何将优化算法集成到Web系统中实现工程化应用；④为算法性能评估与改进提供实践参考； 阅读建议：建议读者结合代码逐行调试，深入理解算法流程中MOA与MOP的作用机制，尝试在不同测试函数上运行算法以观察性能差异，并可进一步扩展图像分割模块，引入更复杂的预处理或后处理技术以提升分割效果。
【微信小程序源码】图文信息；欢迎页面，音乐控制.zip
09-06
资源说明： 1：本资料仅用作交流学习参考，请切勿用于商业用途。 2：一套精品实用微信小程序源码资源，无论是入门练手还是项目复用都超实用，省去重复开发时间，让开发少走弯路！ 更多精品资源请访问 https://blog.youkuaiyun.com/ashyyyy/article/details/146464041
bedrock-testing-support-7.0.4.jar中文-英文对照文档.zip
09-06
1、压缩文件中包含： 中文-英文对照文档、jar包下载地址、Maven依赖、Gradle依赖、源代码下载地址。 2、使用方法： 解压最外层zip，再解压其中的zip包，双击 【index.html】 文件，即可用浏览器打开、进行查看。 3、特殊说明： （1）本文档为人性化翻译，精心制作，请放心使用； （2）只翻译了该翻译的内容，如：注释、说明、描述、用法讲解 等； （3）不该翻译的内容保持原样，如：类名、方法名、包名、类型、关键字、代码 等。 4、温馨提示： （1）为了防止解压后路径太长导致浏览器无法打开，推荐在解压时选择“解压到当前文件夹”（放心，自带文件夹，文件不会散落一地）； （2）有时，一套Java组件会有多个jar，所以在下载前，请仔细阅读本篇描述，以确保这就是你需要的文件。 5、本文件关键字： jar中文-英文对照文档.zip,java,jar包,Maven,第三方jar包,组件,开源组件,第三方组件,Gradle,中文API文档,手册,开发手册,使用手册,参考手册。
【微信小程序源码】物业管理.zip
09-06
资源说明： 1：本资料仅用作交流学习参考，请切勿用于商业用途。 2：一套精品实用微信小程序源码资源，无论是入门练手还是项目复用都超实用，省去重复开发时间，让开发少走弯路！ 更多精品资源请访问 https://blog.youkuaiyun.com/ashyyyy/article/details/146464041
grpc-services-1.68.1.jar中文-英文对照文档.zip
09-06
1、压缩文件中包含： 中文-英文对照文档、jar包下载地址、Maven依赖、Gradle依赖、源代码下载地址。 2、使用方法： 解压最外层zip，再解压其中的zip包，双击 【index.html】 文件，即可用浏览器打开、进行查看。 3、特殊说明： （1）本文档为人性化翻译，精心制作，请放心使用； （2）只翻译了该翻译的内容，如：注释、说明、描述、用法讲解 等； （3）不该翻译的内容保持原样，如：类名、方法名、包名、类型、关键字、代码 等。 4、温馨提示： （1）为了防止解压后路径太长导致浏览器无法打开，推荐在解压时选择“解压到当前文件夹”（放心，自带文件夹，文件不会散落一地）； （2）有时，一套Java组件会有多个jar，所以在下载前，请仔细阅读本篇描述，以确保这就是你需要的文件。 5、本文件关键字： jar中文-英文对照文档.zip,java,jar包,Maven,第三方jar包,组件,开源组件,第三方组件,Gradle,中文API文档,手册,开发手册,使用手册,参考手册。
aws-java-sdk-mediapackagev2-1.12.780.jar中文-英文对照文档.zip
09-06
1、压缩文件中包含： 中文-英文对照文档、jar包下载地址、Maven依赖、Gradle依赖、源代码下载地址。 2、使用方法： 解压最外层zip，再解压其中的zip包，双击 【index.html】 文件，即可用浏览器打开、进行查看。 3、特殊说明： （1）本文档为人性化翻译，精心制作，请放心使用； （2）只翻译了该翻译的内容，如：注释、说明、描述、用法讲解 等； （3）不该翻译的内容保持原样，如：类名、方法名、包名、类型、关键字、代码 等。 4、温馨提示： （1）为了防止解压后路径太长导致浏览器无法打开，推荐在解压时选择“解压到当前文件夹”（放心，自带文件夹，文件不会散落一地）； （2）有时，一套Java组件会有多个jar，所以在下载前，请仔细阅读本篇描述，以确保这就是你需要的文件。 5、本文件关键字： jar中文-英文对照文档.zip,java,jar包,Maven,第三方jar包,组件,开源组件,第三方组件,Gradle,中文API文档,手册,开发手册,使用手册,参考手册。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值