Golang---高并发

【Golang】Go语言中如何通过Goroutine快速实现高并发 并发编程是指在一个程序中同时运行多个任务,这些任务可以独立地执行,也可以相互协作。并发编程可以提高程序的执行效率,特别是在处理大量I/O操作或计算密集型任务时。 在Go语言中,并发编程主要通过goroutine和channel来实现。 Goroutine是Go语言独有的并发执行单元,它允许函数或方法并发执行,而无需手动管理线程。 Channel是Go语言中进行goroutine间通信和同步的主要机制。 阅读详情
       golang从语言级别上对并发提供了支持,而且在启动并发的方式上直接添加了语言级的关键字。我并不会很多语言,而且也没有很多的项目经验,可能从我嘴里说出的比较不会非常客观,但是起码和C/C++(不考虑C++11)利用系统API来操作线程的方式相比,golang的并发机制运用起来就非常舒适了,不必非要按照固定的格式来定义线程函数,也不必因为启动线程的时候只能给线程函数传递一个参数而烦恼。和Java相比的话,go的优点就是并发的部分不必非得实现成一个class,而且更加轻量。

并发的启动

这篇文章关于并发的启动我就一概而过了,如果要让一个函数并发运行,只需一个关键字"go":

func Afuntion(para1, para2, para3, ...) {
	// Do some process
	// ...
}

func main() {
	go Afuntion(para1, para2, para3, ...) //只需加一个go前缀,Afunction()就会并发运行
}
go的并发启动非常简单,几乎没有什么额外的准备工作,要并发的函数和一般的函数没有什么区别,参数随意,启动的时候只需要加一个go关键之即可。


当然,并发的启动没什么好讲的,并发最精髓的部分在于这些协程(协程类似于线程,但是是更轻量的线程)的调度。

我没法以一个资深的老专家向你全方位的讲解调度的各个方面,但是我可以把我遇到过的一些场景和我所用过的调度方法(所以绝对是能用的)分享给你。


go提供了sync包和channel机制来解决协程间的同步与通信。channel的用法非常灵活,使用的方式多种多样,而且官网的Effective Go中给出了channel的一种并发以外的方式。我们先来介绍sync包提供的调度支持吧。



sync.WaitGroup

sync包中的WaitGroup实现了一个类似任务队列的结构,你可以向队列中加入任务,任务完成后就把任务从队列中移除,如果队列中的任务没有全部完成,队列就会触发阻塞以阻止程序继续运行,具体用法参考如下代码:

// 代码粘上就可以跑通
package main

import (
	"fmt"
	"sync"
)

var waitgroup sync.WaitGroup

func Afunction(shownum int) {
	fmt.Println(shownum)
	waitgroup.Done() //任务完成,将任务队列中的任务数量-1,其实.Done就是.Add(-1)
}

func main() {
	for i := 0; i < 10; i++ {
		waitgroup.Add(1) //每创建一个goroutine,就把任务队列中任务的数量+1
		go Afunction(i)
	}
	waitgroup.Wait() //.Wait()这里会发生阻塞,直到队列中所有的任务结束就会解除阻塞
}
我们可以利用sync.WaitGroup来满足这样的情况:

        ▲某个地方需要创建多个goroutine,并且一定要等它们都执行完毕后再继续执行接下来的操作。

是的,WaitGroup最大的优点就是.Wait()可以阻塞到队列中的任务都完毕后才解除阻塞。


channel
channel是一种golang内置的类型,英语的直译为"通道",其实,它真的就是一根管道,而且是一个先进先出的数据结构。


我们能对channel进行的操作只有4种:

(1) 创建chennel (通过make()函数)

(2) 放入数据 (通过 channel <- data 操作) 

(3) 取出数据 (通过 <-channel 操作)

(4)  关闭channel (通过close()函数)


但是channel有一些非常给力的性质需要你牢记,请一定要记住并理解好它们:

(1) channel是一种阻塞管道,是自动阻塞的。意思就是,如果管道满了,一个对channel放入数据的操作就会阻塞,直到有某个routine从channel中取出数据,这个放入数据的操作才会执行。相反同理,如果管道是空的,一个从channel取出数据的操作就会阻塞,直到某个routine向这个channel中放入数据,这个取出数据的操作才会执行。这事channel最重要的一个性质,没有之一。

package main

func main() {
	ch := make(chan int, 3)
	ch <- 1
	ch <- 1
	ch <- 1
	ch <- 1 //这一行操作就会发生阻塞,因为前三行的放入数据的操作已经把channel填满了
}


package main

func main() {
	ch := make(chan int, 3)
	<-ch //这一行会发生阻塞,因为channel才刚创建,是空的,没有东西可以取出
}

(2)channel分为有缓冲的channel和无缓冲的channel。两种channel的创建方法如下:

ch := make(chan int) //无缓冲的channel,同等于make(chan int, 0)
ch := make(chan int, 5) //一个缓冲区大小为5的channel


操作一个channel时一定要注意其是否带有缓冲,因为有些操作会触发channel的阻塞导致死锁。下面就来解释这些需要注意的情景。

首先来看一个一个例子,这个例子是两段只有主函数不同的代码:

package main

import "fmt"

func Afuntion(ch chan int) {
	fmt.Println("finish")
	<-ch
}

func main() {
	ch := make(chan int) //无缓冲的channel
	go Afuntion(ch)
	ch <- 1
	
	// 输出结果:
	// finish
}


package main

import "fmt"

func Afuntion(ch chan int) {
	fmt.Println("finish")
	<-ch
}

func main() {
	ch := make(chan int) //无缓冲的channel
	//只是把这两行的代码顺序对调一下
	ch <- 1
	go Afuntion(ch)

	// 输出结果:
	// 死锁,无结果
}

前一段代码最终会输出"finish"并正常结束,但是后一段代码会发生死锁。为什么会出现这种现象呢,咱们把上面两段代码的逻辑跑一下。

第一段代码:

        1. 创建了一个无缓冲channel

        2. 启动了一个goroutine,这个routine中对channel执行取出操作,但是因为这时候channel为空,所以这个取出操作发生阻塞,但是主routine可没有发生阻塞,它还在继续运行呢

        3. 主goroutine这时候继续执行下一行,往channel中放入了一个数据

        4. 这时阻塞的那个routine检测到了channel中存在数据了,所以接触阻塞,从channel中取出数据,程序就此完毕


第二段代码:

        1.  创建了一个无缓冲的channel

        2.  主routine要向channel中放入一个数据,但是因为channel没有缓冲,相当于channel一直都是满的,所以这里会发生阻塞。可是下面的那个goroutine还没有创建呢,主routine在这里一阻塞,整个程序就只能这么一直阻塞下去了,然后。。。然后就没有然后了。。死锁!

※从这里可以看出,对于无缓冲的channel,放入操作和取出操作不能再同一个routine中,而且应该是先确保有某个routine对它执行取出操作,然后才能在另一个routine中执行放入操作。


对于带缓冲的channel,就没那么多讲究了,因为有缓冲空间,所以只要缓冲区不满,放入操作就不会阻塞,同样,只要缓冲区不空,取出操作就不会阻塞。而且,带有缓冲的channel的放入和取出可以用在同一个routine中。

但是,并不是说有了缓冲就可以随意使用channel的放入和取出了,我们一定要注意放入和取出的速率问题。下面我们就举个例子来说明这种问题:

我们经常会用利用channel自动阻塞的性质来控制当前运行的goroutine的总数量,如下:

package main

import (
	"fmt"
)

func Afunction(ch chan int) {
	fmt.Println("finish")
	<-ch //goroutine执行完了就从channel取出一个数据
}

func main() {
	ch := make(chan int, 10)
	for i := 0; i < 1000; i++ {
		//每当创建goroutine的时候就向channel中放入一个数据,如果里面已经有10个数据了,就会
		//阻塞,由此我们将同时运行的goroutine的总数控制在<=10个的范围内
		ch <- 1
		go Afunction(ch)
	}
	// 这里只是示范个例子,当然,接下来应该有些更加周密的同步操作
}


上面这种channel的使用方式几乎经常会用到,但是再看一下接下来这段代码,它和上面这种使用channel的方式几乎一样,但是它会造成问题:
package main

func Afunction(ch chan int) {
	ch <- 1
	ch <- 1
	ch <- 1
	ch <- 1
	ch <- 1

	<-ch
}

func main() {
	//主routine的操作同上面那段代码
	ch := make(chan int, 10)
	for i := 0; i < 100; i++ {
		ch <- 1
		go Afunction(ch)
	}

	// 这段代码运行的结果为死锁
}

上面这段运行和之前那一段基本上原理是一样的,但是运行后却会发生死锁。为什么呢?其实总结起来就一句话,"放得太快,取得太慢了"。

按理说,我们应该在我们主routine中创建子goroutine并每次向channel中放入数据,而子goroutine负责从channel中取出数据。但是我们的这段代码在创建了子goroutine后,每个routine会向channel中放入5个数据。这样,每向channel中放入6个数据才会执行一次取出操作,这样一来就可能会有某一时刻,channel已经满了,但是所有的routine都在执行放入操作(因为它们当前执行放入操作的概率是执行取出操作的6倍),这样一来,所有的routine都阻塞了,从而导致死锁。


在使用带缓冲的channel时一定要注意放入与取出的速率问题。


(3)关闭后的channel可以取数据,但是不能放数据。而且,channel在执行了close()后并没有真的关闭,channel中的数据全部取走之后才会真正关闭。

package main

func main() {
	ch := make(chan int, 5)
	ch <- 1
	ch <- 1
	close(ch)
	ch <- 1 //不能对关闭的channel执行放入操作
        
        // 会触发panic
}


package main

func main() {
	ch := make(chan int, 5)
	ch <- 1
	ch <- 1
	close(ch)
	<-ch //只要channel还有数据,就可能执行取出操作

        //正常结束
}


package main

import "fmt"

func main() {
	ch := make(chan int, 5)
	ch <- 1
	ch <- 1
	ch <- 1
	ch <- 1
	close(ch)  //如果执行了close()就立即关闭channel的话,下面的循环就不会有任何输出了
	for {
		data, ok := <-ch
		if !ok {
			break
		}
		fmt.Println(data)
	}
	
	// 输出:
	// 1
	// 1
	// 1
	// 1
	// 
	// 调用了close()后,只有channel为空时,channel才会真的关闭
}



使用channel控制goroutine数量

channel的性质到这里就介绍完了,但是看上去,channel的使用似乎比WaitGroup要注意更多的细节,那么有什么理由一定要用channel来实现同步呢?channel相比WaitGroup有一个很大的优点,就是channel不仅可以实现协程的同步,而且可以控制当前正在运行的goroutine的总数。

下面就介绍几种利用channel控制goroutine数量的方法:

一.如果任务数量是固定的:

package main

func Afunction(ch chan int) {
	ch <- 1
}

func main() {
	var (
		ch        chan int = make(chan int, 20) //可以同时运行的routine数量为20
		dutycount int      = 500
	)
	for i := 0; i < dutycount; i++ {
		go Afunction(ch)
	}

	//知道了任务总量,可以像这样利用固定循环次数的循环检测所有的routine是否工作完毕
	for i := 0; i < dutycount; i++ {
		<-ch
	}
}

二.如果任务的数量不固定
package main

import (
	"fmt"
)

func Afunction(routineControl chan int, feedback chan string) {
	defer func() {
		<-routineControl
		feedback <- "finish"
	}()

	// do some process
	// ...
}

func main() {
	var (
		routineCtl chan int    = make(chan int, 20)
		feedback   chan string = make(chan string, 10000)

		msg      string
		allwork  int
		finished int
	)
	for i := 0; i < 1000; i++ {
		routineCtl <- 1
		allwork++
		go Afunction(routineCtl, feedback)
	}

	for {
		msg = <-feedback
		if msg == "finish" {
			finished++
		}
		if finished == allwork {
			break
		}
	}
}

转载:http://blog.youkuaiyun.com/gophers/article/details/24665419
Workbench-nCode下发动机引擎应力疲劳分析 在工程数据库中定义材料模型参数,结构场分析基本参数:密度7850Kg/m3、弹性模量210E9Pa、泊松比0.3,疲劳分析参数:应力-疲劳曲线表(S-N Curve),应力-疲劳曲线如下图2所示,如果没有合适的数据可使用结构钢材料进行分析。网格为四面体高阶单元,各零件的单元尺寸如下表1所示,单元质量分布如下图3所示。在workbench平台下搭建分析流程如下图6所示,前述设定完成后,提交求解后即可得到相应的应力、应变结果,更新结果后目录树中会有相应的nCode DesignLife插件,如下图7所示。 阅读详情

相关推荐

Web安全基础知识整理

最近阿菜姐我研究了一下web相关的安全问题,现在梳理一下内容。 如果您想给自己立个Web安全大佬的flag,那么您必须知道在这个网站:https://owasp.org/ OWASP?是开放式Web应用程序安全项目,是致力于网络应用程序安全的国际非营利组织。我们可以在其网站上免费获得他们提供的文档,工具,视频和论坛等所有资料。同时我们还要关注该网站定期更新的OWASP Top 10报告。这不但能提升我们的英语阅读能力,还能在同行里制造话题,显得我们B格很高。 ...

qq_33409012的博客 4093

Go高并发微服务分布式实战

/ users[id] => 在 不在(你输入的用户ID不正确)// users[id] => 在 不在(你输入的用户ID不正确)在程序中定义PASSWORD = "!值类型使用string。=> 用户 ID name age tel addr。// 打印用户信息,提示用户是否确认修改(Y/N)// 打印用户信息,提示用户是否确认删除(Y/N)提示输入密码,如果密码输出3次都失败,提示并退出。// Y 提示用户输入修改后内容。如果密码成功,再进行用户管理操作。=> 结构 [] map。

niwoxiangyu的博客 4967

AI Agent开发大全第一课-AI是什么以及如何使用AI

近年来,人工智能的迅猛发展引发了广泛的关注,尤其是“大模型”这一概念越来越深入人心。大模型,顾名思义,通常指的是那些拥有大量参数、能够处理复杂任务的机器学习模型。与传统小模型相比,大模型在数据处理、信息理解和生成等方面表现更加出色。为了理解为什么现在的AI被称为大模型,我们需要深入探讨几个关键因素。立角色是指在提示词中清晰地界定交互双方的身份。明确用户希望模型扮演的角色,可以帮助模型更准确地理解上下文和用户需求。

打造全国最全的AI Agent开发知识领域的博客 1412

Go 如何应对高并发 | 高并发详解

并发编程是当前软件领域中一个重要的概念。Go语言通过goroutine和channel的特性,天生支持高并发处理,充分利用现代CPU的多核优势。与Java相比,Go语言的协程更加轻量级,可以轻松创建上百万个协程。Go语言的调度器采用GPM调度模型,通过将协程放入队列中,由调度器分配给CPU处理。此外,Go语言采用CSP模型,通过channel实现协程之间的通信,避免了共享内存带来的竞态问题。相比之下,Go语言的Mutex锁更轻量、灵活,并且具有更高的性能。

Lamb的博客 1893

69页完整版智慧港口综合解决方案

智慧港口需求4港机远程操控等自动化改造需求自动化码头AGV无线通信及专用视频系统需求安全生产视频监控类需求港机RCMS及设备管理需求岸边智能理货码头三维全景应用智慧港口解决方案5自动化码头AGV/跨运车/无人集卡无线接入港机远控视觉及冗余无线通信视觉集卡防吊起系统集装箱码头岸边智能理货港机RCMS系统无线接入港机智能化管理(无线高清视频监控、一键报警、远程抄表系统)港口拖轮无线接入岸边溢油监测系统TD-LTE覆盖及业务终端接入港口生产管理系统港口可视化集群调度港口GiNMS综合网络设备智能管理全球作业效率最

zuoan1993的博客 2131

优快云独家 | 全网首发 | 《目标检测蓝皮书》目录

10篇文章从目标检测小白变大神

Coding... 3万+

【Go系列】 Go的高并发模式

我们在之前已经学习了goroutine和channel的并发模式,也学会了sync库和context的控制。那么在Go里面一般都会使用哪些高并发模式呢?今天让我们在这篇文章中一起揭晓一下。

u013379032的博客 1473

把 MCP Server 直接装进 SAP ABAP:用 Unlimited Display Tools 打通 Agentic SDK 与 SAP ECC / S/4HANA 的最后一公里

摘要:AI与SAP集成的MCP解决方案 企业在AI集成中面临工具链复杂、数据对接繁琐的挑战。Model Context Protocol (MCP)通过标准化工具与数据暴露方式,将集成复杂度从N×M降至N+M。在SAP生态中,MCP Server for SAP直接部署于ABAP层,利用DDIC/CDS视图对接各类Agent SDK,避免中间件风险。 MCP核心包含三类对象: Tools:带元数据的可执行动作 Resources:结构化上下文数据 Prompts:可参数化提示模板 ABAP层实现MCP Se

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 691

Go语言高并发系列一:基础理论

Go语言的一个核心优势就是它的并发能力。但是在实际工作中,有很多小伙伴还不能纯熟的掌握Go语言的并发和goroutine的控制,导致有时候会出现一些性能问题和严重的bug。 所以我准备写四篇文章来系统的整理一下Go语言并发相关的知识,自己复习的同时,也可以给公司的其他小伙伴巩固一下,顺便介绍一下我封装的一些并发控制器,方便其他小伙伴使用。 闲话不多说了,下面进入正题。 我打算写总共四篇文章来梳理Go语言并发的核心知识: 基础理论 goroutine基础 context 并发模式 进程 进程的定义 进程是

h1993726的博客 1791

SAP Event Mesh 简介

Get Started with Messaging for Decoupled Communication Step 1: What is the SAP Event Mesh service? SAP Event Mesh 是一种完全托管的服务,用于连接应用程序、服务和系统,以便它们可以通过消息和事件相互交互。 它通过引入中央消息代理取代了传统的点对点通信。 虽然点对点通信适用于在有限数量的发送方和接收方之间共享数据,但可扩展性很快就会成为一个问题。 SAP Event Mesh 解决了这个问题,并确保

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 1244

DeepLabv3+改进68:全网首发-添加DBlock模块 |高效且鲁棒的多任务低光图像修复神经网络

本文提出了一种高效鲁棒的多任务低光图像修复神经网络DarkIR,针对夜间或昏暗条件下图像存在的噪点、光线不足和模糊问题。不同于现有方法分别处理去模糊和低光增强任务,该模型采用新的注意力机制增强CNN感受野,在降低计算成本的同时,在LOL-Blur、LOLv2和Real-LOLBlur数据集上取得最优结果,并能良好泛化到真实夜间图像。

AIcurator的博客 326

Go语言(Golang)如何处理高并发?

当一个goroutine阻塞时(例如,等待channel中的数据),Go运行时会自动将其挂起,并调度其他可用的goroutine执行,从而充分利用CPU资源。与传统的线程不同,goroutines非常轻量,它们的创建和销毁成本极低,这使得在Go应用中可以轻易地创建成千上万个并发执行的goroutines。Go语言在设计之初就充分考虑了并发性,通过引入轻量级的线程——goroutines和高效的通信机制——channels,为开发者提供了一种简洁而强大的并发编程模型。来自:www.kykzl.com。

2401_84297774的博客 1763

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

高并发go和php,golang 为什么高并发

GO语言在WEB开发领域中的使用越来越广泛,Hired 发布的《2019 软件工程师状态》报告中指出,具有 Go 经验的候选人是迄今为止最具吸引力的。 (推荐学习:go)高并发(High Concurrency)是互联网分布式系统架构设计中必须考虑的因素之一,它通常是指,通过设计保证系统能够同时并行处理很多请求。go...

weixin_42443992的博客 504

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

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

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

golang高并发的理解

前言 GO语言在WEB开发领域中的使用越来越广泛,Hired 发布的《2019 软件工程师状态》报告中指出,具有 Go 经验的候选人是迄今为止最具吸引力的。平均每位求职者会收到9 份面试邀请。 想学习go,最基础的就要理解go是怎么做到高并发的。 那么什么是高并发? 高并发(High Concurrency)是互联网分布式系统架构设计中必须考虑的因素之一,它通常是指,通过设计保证系统能够同时并行处...

飞翔码农的博客 4825

Golang之高并发原理

用一个简单的web服务探究golang的高并发原理 高并发(High Concurrency)是互联网分布式系统架构设计中必须考虑的因素之一,它通常是指,通过设计保证系统能够同时并行处理很多请求。要做到高并发,就要做到资源合理分配,需要多少就分配多少,反之小马拉大车,拉不动,大马拉小二轮,造成资源浪费。 严格意义上说,单核的CPU是没法做到并行的,只有多核的CPU才能做到严格意义上的并行,因为一个CPU同时只能做一件事。那为什么是单核的CPU也能做到高并发。这就是操作系统...

Linzhongyilisha的专栏 1512

Golang企业级商城高并发微服务实战

从零开始讲了百万级单体高并发架构、千万级微服务架构,其中包含Rpc实现微服务、微服务的跨语言调用jsonrpc和protobuf、protobuf的安装、protobuf高级语法、protobuf结合Grpc实现微服务实战等内容。

yuanlaile的博客 1423

golang是如何实现高并发的?深入领会MPG模式

前天去面试,被问到golang是如何实现高并发的,之前在&amp;amp;amp;lt;

zzr881的博客 8932

Golang高并发原理

软件的处理能力不仅仅跟内存有关,还有是否阻塞,是否异步处理,CPU等等。那么是不是可以有一种语言使用更小的处理单元,占用内存比线程更小,那么它的并发处理能力就可以更高。所以Google就做了这件事,就有了golang语言,golang从语言层面就支持了高并发。 go的高并发处理核心 - goroutine goroutine是Go并行设计的核心。goroutine说到底其实就是协程,它比线程更...

Linzhongyilisha的专栏 726

Golang高并发爬虫:构建智能AI数据管道实现结构化信息采集(Go-zero实战)

本文介绍了如何利用Go语言构建高效智能的数据采集系统,用于医疗信息化领域。作者分享了基于Go和AI技术构建的数据处理流水线实战经验,重点讲解了高并发爬虫集群的设计与实现。文章详细阐述了Go语言的Goroutine和Channel机制如何解决I/O密集型采集任务,并展示了使用go-zero框架搭建微服务的具体步骤,包括API定义、代码生成和核心采集逻辑的实现。这套方案有效解决了医疗数据采集中的时效性和准确性问题。

张国良的博客 1510

golang高并发

golang 为什么能做到高并发 goroutine是go并行的关键,goroutine说到底就是携程,但是他比线程更小,几十个goroutine可能体现在底层就是五六个线程,Go语言内部帮你实现了这些goroutine之间的内存共享。执行goroutine只需极少的栈内存(大概是4~5KB),当然会根据相应的数据伸缩。也正因为如此,可同时运行成千上万个并发任务。goroutine比thre...

weixin_30703911的博客 107

go语言golang高并发需要注意哪些核心要点

golang处理高并发是不可避免的一件事,如果要支持10万级QPS的高并发系统,同时保证内存安全与执行效率,我们需要注意几个核心要点。

qq_42942935的博客 544

为什么大厂都在用Go?揭秘Golang在高并发场景下的绝对优势

掌握高并发编程难题?本go语言入门教程揭秘大厂青睐Go的真相,解析Golang在微服务、云计算中的高性能优势,涵盖协程、通道等核心机制,助你快速上手。值得收藏的实战指南,点击了解。

BreakNexus的博客 1053

go的高并发原理

Go语言由Google工程师团队于2007年开始设计,2009年正式发布。它是一门天生支持高并发的语言,那它为什么天生支持高并发呢?下面是笔者对此发表的一些见解。协程革命:用户态轻量线程+智能调度,解决传统线程资源瓶颈并发原语:Channel+CSP模型实现安全的并发通信运行时优化:Netpoller统一网络IO模型,GC演进保障内存安全工具链支撑:内置race detector、pprof等工具完善开发生态。

goislaji的博客 1494
上一篇: Golang---walk学习(一)
下一篇: Golang---goquery爬虫获取golang语言中文网页面信息并保存MySQL
Kuberlin
博客等级 码龄12年 4粉丝 4原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值