【耀华地磅源码】【lag窗口函数 源码】【流通市值 指标源码】data sync源码

时间:2024-12-24 07:36:08 编辑:unity游戏项目源码 来源:堆金叠玉指标源码

1.Go看源码必会知识之unsafe包
2.Spring Boot + EasyExcel导入导出,源码简直太好用了!源码
3.vue-srr 实现原理( vuex、源码vue-router、源码syncData )
4.Go并发编程:goroutine,channel和sync详解

data sync源码

Go看源码必会知识之unsafe包

       前言

       有看源码的源码朋友应该会发现,Go标准库中大量使用了unsafe.pointer,源码耀华地磅源码要想更好的源码理解源码实现,就要知道unsafe.pointer到底是源码什么?所以今天就与大家来聊一聊unsafe包。

什么是源码unsafe

       众所周知,Go语言被设计成一门强类型的源码静态语言,那么他的源码类型就不能改变了,静态也是源码意味着类型检查在运行前就做了。所以在Go语言中是源码不允许两个指针类型进行转换的,使用过C语言的源码朋友应该知道这在C语言中是可以实现的,Go中不允许这么使用是源码处于安全考虑,毕竟强制转型会引起各种各样的麻烦,有时这些麻烦很容易被察觉,有时他们却又隐藏极深,难以察觉。大多数读者可能不明白为什么类型转换是不安全的,这里用C语言举一个简单的例子:

int main(){ double pi = 3.;double *pv = πvoid *temp = pd;int *p = temp;}

       在标准C语言中,任何非void类型的指针都可以和void类型的指针相互指派,也可以通过void类型指针作为中介,实现不同类型的指针间接相互转换。上面示例中,指针pv指向的空间本是一个双精度数据,占8个字节,但是经过转换后,p指向的是一个4字节的int类型。这种发生内存截断的设计缺陷会在转换后进行内存访问是存在安全隐患。我想这就是Go语言被设计成强类型语言的原因之一吧。

       虽然类型转换是不安全的,但是在一些特殊场景下,使用了它,可以打破Go的类型和内存安全机制,可以绕过类型系统低效,提高运行效率。所以Go标准库中提供了一个unsafe包,之所以叫这个名字,就是不推荐大家使用,但是不是不能用,如果你掌握的特别好,还是可以实践的。

unsafe 实现原理

       在使用之前我们先来看一下unsafe的源码部分,标准库unsafe包中只提供了3``种方法,分别是:

func Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr

       Sizeof(x ArbitrayType)方法主要作用是用返回类型x所占据的字节数,但并不包含x所指向的内容的大小,与C语言标准库中的Sizeof()方法功能一样,比如在位机器上,一个指针返回大小就是4字节。

       Offsetof(x ArbitraryType)方法主要作用是返回结构体成员在内存中的位置离结构体起始处(结构体的第一个字段的偏移量都是0)的字节数,即偏移量,我们在注释中看一看到其入参必须是lag窗口函数 源码一个结构体,其返回值是一个常量。

       Alignof(x ArbitratyType)的主要作用是返回一个类型的对齐值,也可以叫做对齐系数或者对齐倍数。对齐值是一个和内存对齐有关的值,合理的内存对齐可以提高内存读写的性能。一般对齐值是2^n,最大不会超过8(受内存对齐影响).获取对齐值还可以使用反射包的函数,也就是说:unsafe.Alignof(x)等价于reflect.TypeOf(x).Align()。对于任意类型的变量x,unsafe.Alignof(x)至少为1。对于struct结构体类型的变量x,计算x每一个字段f的unsafe.Alignof(x,f),unsafe.Alignof(x)等于其中的最大值。对于array数组类型的变量x,unsafe.Alignof(x)等于构成数组的元素类型的对齐倍数。没有任何字段的空struct{ }和没有任何元素的array占据的内存空间大小为0,不同大小为0的变量可能指向同一块地址。

       细心的朋友会发发现这三个方法返回的都是uintptr类型,这个目的就是可以和unsafe.poniter类型相互转换,因为*T是不能计算偏移量的,也不能进行计算,但是uintptr是可以的,所以可以使用uintptr类型进行计算,这样就可以可以访问特定的内存了,达到对不同的内存读写的目的。三个方法的入参都是ArbitraryType类型,代表着任意类型的意思,同时还提供了一个Pointer指针类型,即像void *一样的通用型指针。

type ArbitraryType inttype Pointer *ArbitraryType// uintptr 是一个整数类型,它足够大,可以存储type uintptr uintptr

       上面说了这么多,可能会有点懵,在这里对三种指针类型做一个总结:

       *T:普通类型指针类型,用于传递对象地址,不能进行指针运算。

       unsafe.poniter:通用指针类型,用于转换不同类型的指针,不能进行指针运算,不能读取内存存储的值(需转换到某一类型的普通指针)

       uintptr:用于指针运算,GC不把uintptr当指针,uintptr无法持有对象。uintptr类型的目标会被回收。

       三者关系就是:unsafe.Pointer是桥梁,可以让任意类型的指针实现相互转换,也可以将任意类型的指针转换为uintptr进行指针运算,也就说uintptr是用来与unsafe.Pointer打配合,用于指针运算。画个图表示一下:

       基本原理就说到这里啦,接下来我们一起来看看如何使用~

unsafe.Pointer基本使用

       我们在上一篇分析atomic.Value源码时,看到atomic/value.go中定义了一个ifaceWords结构,流通市值 指标源码其中typ和data字段类型就是unsafe.Poniter,这里使用unsafe.Poniter类型的原因是传入的值就是interface{ }类型,使用unsafe.Pointer强转成ifaceWords类型,这样可以把类型和值都保存了下来,方便后面的写入类型检查。截取部分代码如下:

// ifaceWords is interface{ } internal representation.type ifaceWords struct { typunsafe.Pointer data unsafe.Pointer}// Load returns the value set by the most recent Store.// It returns nil if there has been no call to Store for this Value.func (v *Value) Load() (x interface{ }) { vp := (*ifaceWords)(unsafe.Pointer(v))for { typ := LoadPointer(&vp.typ) // 读取已经存在值的类型/**..... 中间省略**/// First store completed. Check type and overwrite data.if typ != xp.typ { //当前类型与要存入的类型做对比 panic("sync/atomic: store of inconsistently typed value into Value")}}

       上面就是源码中使用unsafe.Pointer的一个例子,有一天当你准备读源码时,unsafe.pointer的使用到处可见。好啦,接下来我们写一个简单的例子,看看unsafe.Pointer是如何使用的。

func main(){ number := 5 pointer := &number fmt.Printf("number:addr:%p, value:%d\n",pointer,*pointer) floatNumber := (*float)(unsafe.Pointer(pointer)) *floatNumber = *floatNumber + 3 fmt.Printf("float:addr:%p, value:%f\n",floatNumber,*floatNumber)}

       运行结果:

number:addr:0xc, value:5float:addr:0xc, value:3.

       由运行可知使用unsafe.Pointer强制类型转换后指针指向的地址是没有改变,只是类型发生了改变。这个例子本身没什么意义,正常项目中也不会这样使用。

       总结一下基本使用:先把*T类型转换成unsafe.Pointer类型,然后在进行强制转换转成你需要的指针类型即可。

Sizeof、Alignof、Offsetof三个函数的基本使用

       先看一个例子:

type User struct { Name string Age uint Gender bool // 男:true 女:false 就是举个例子别吐槽我这么用。。。。}func func_example(){ // sizeof fmt.Println(unsafe.Sizeof(true)) fmt.Println(unsafe.Sizeof(int8(0))) fmt.Println(unsafe.Sizeof(int())) fmt.Println(unsafe.Sizeof(int())) fmt.Println(unsafe.Sizeof(int())) fmt.Println(unsafe.Sizeof("asong")) fmt.Println(unsafe.Sizeof([]int{ 1,3,4})) // Offsetof user := User{ Name: "Asong", Age: ,Gender: true} userNamePointer := unsafe.Pointer(&user) nNamePointer := (*string)(unsafe.Pointer(userNamePointer)) *nNamePointer = "Golang梦工厂" nAgePointer := (*uint)(unsafe.Pointer(uintptr(userNamePointer) + unsafe.Offsetof(user.Age))) *nAgePointer = nGender := (*bool)(unsafe.Pointer(uintptr(userNamePointer)+unsafe.Offsetof(user.Gender))) *nGender = false fmt.Printf("u.Name: %s, u.Age: %d,u.Gender: %v\n", user.Name, user.Age,user.Gender) // Alignof var b bool var i8 int8 var i int var i int var f float var s string var m map[string]string var p *int fmt.Println(unsafe.Alignof(b)) fmt.Println(unsafe.Alignof(i8)) fmt.Println(unsafe.Alignof(i)) fmt.Println(unsafe.Alignof(i)) fmt.Println(unsafe.Alignof(f)) fmt.Println(unsafe.Alignof(s)) fmt.Println(unsafe.Alignof(m)) fmt.Println(unsafe.Alignof(p))}

       为了省事,把三个函数的使用示例放到了一起,首先看sizeof方法,我们可以知道各个类型所占字节大小,这里重点说一下int类型,Go语言中的int类型的具体大小是跟机器的 CPU位数相关的。如果 CPU 是 位的,那么int就占4字节,如果 CPU是位的,那么 int 就占8 字节,这里我的电脑是位的,所以结果就是8字节。

       然后我们在看Offsetof函数,我想要修改结构体中成员变量,第一个成员变量是不需要进行偏移量计算的,直接取出指针后转换为unsafe.pointer,在强制给他转换成字符串类型的指针值即可。如果要修改其他成员变量,需要进行偏移量计算,才可以对其内存地址修改,所以Offsetof方法就可返回成员变量在结构体中的偏移量,也就是返回结构体初始位置到成员变量之间的字节数。看代码时大家应该要住uintptr的使用,不可以用一个临时变量存储uintptr类型,前面我们提到过用于指针运算,GC不把uintptr当指针,uintptr无法持有对象。uintptr类型的目标会被回收,所以你不知道他什么时候会被GC掉,idea源码是什么那样接下来的内存操作会发生什么样的错误,咱也不知道。比如这样一个例子:

// 切记不要这样使用p1 := uintptr(userNamePointer)nAgePointer := (*uint)(unsafe.Pointer(p1 + unsafe.Offsetof(user.Age)))

       最后看一下Alignof函数,主要是获取变量的对齐值,除了int、uintptr这些依赖CPU位数的类型,基本类型的对齐值都是固定的,结构体中对齐值取他的成员对齐值的最大值,结构体的对齐涉及到内存对齐,我们在下面详细介绍。

经典应用:string与[]byte的相互转换

       实现string与byte的转换,正常情况下,我们可能会写出这样的标准转换:

// string to []bytestr1 := "Golang梦工厂"by := []byte(s1)// []byte to stringstr2 := string(by)

       使用这种方式进行转换都会涉及底层数值的拷贝,所以想要实现零拷贝,我们可以使用unsafe.Pointer来实现,通过强转换直接完成指针的指向,从而使string和[]byte指向同一个底层数据。在reflect包中有·string和slice对应的结构体,他们的分别是:

type StringHeader struct { Data uintptr Lenint}type SliceHeader struct { Data uintptr Lenint Capint}

       StringHeader代表的是string运行时的表现形式(SliceHeader同理),通过对比string和slice运行时的表达可以看出,他们只有一个Cap字段不同,所以他们的内存布局是对齐的,所以可以通过unsafe.Pointer进行转换,因为可以写出如下代码:

func Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr0

       上面的代码我们通过重新构造slice header和string header完成了类型转换,其实[]byte转换成string可以省略掉自己构造StringHeader的方式,直接使用强转就可以,因为string的底层也是[]byte,强转会自动构造,省略后的代码如下:

func Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr1

       虽然这种方式更高效率,但是不推荐大家使用,前面也提高到了,这要是不安全的,使用当不当会出现极大的隐患,一些严重的情况recover也不能捕获。

内存对齐

       现在计算机中内存空间都是按照byte划分的,从理论上讲似乎对任何类型的变量的访问可以从任何地址开始,但是实际情况是在访问特定类型变量的时候经常在特定的内存地址访问,这就需要各种类型数据按照一定的规则在空间上排列,而不是顺序的一个接一个的排放,这就对齐。

       对齐的作用和原因:CPU访问内存时,并不是逐个字节访问,而是以字长(word size)单位访问。比如位的CPU,字长为4字节,那么CPU访问内存的单位也是4字节。这样设计可以减少CPU访问内存的次数,加大CPU访问内存的吞吐量。假设我们需要读取8个字节的数据,一次读取4个字节那么就只需读取2次就可以。内存对齐对实现变量的原子性操作也是有好处的,每次内存访问都是spring源码笔记周瑜原子的,如果变量的大小不超过字长,那么内存对齐后,对该变量的访问就是原子的,这个特性在并发场景下至关重要。

       我们来看这样一个例子:

func Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr2

       从结果可以看出,字段放置不同的顺序,占用内存也不一样,这就是因为内存对齐影响了struct的大小,所以有时候合理的字段可以减少内存的开销。下面我们就一起来分析一下内存对齐,首先要明白什么是内存对齐的规则,C语言的对齐规则与Go语言一样,所以C语言的对齐规则对Go同样适用:

       对于结构的各个成员,第一个成员位于偏移为0的位置,结构体第一个成员的偏移量(offset)为0,以后每个成员相对于结构体首地址的 offset 都是该成员大小与有效对齐值中较小那个的整数倍,如有需要编译器会在成员之间加上填充字节。

       除了结构成员需要对齐,结构本身也需要对齐,结构的长度必须是编译器默认的对齐长度和成员中最长类型中最小的数据大小的倍数对齐。

       好啦,知道规则了,我们现在来分析一下上面的例子,根据我的mac使用的位CPU,对齐参数是8来分析,int、[]int、string、bool对齐值分别是4、8、8、1,占用内存大小分别是4、、、1,我们先根据第一条对齐规则分析User1:

       第一个字段类型是int,对齐值是4,大小为4,所以放在内存布局中的第一位.

       第二个字段类型是[]int,对齐值是8,大小为,所以他的内存偏移值必须是8的倍数,所以在当前user1中,就不能从第4位开始了,必须从第5位开始,也就偏移量为8。第4,5,6,7位由编译器进行填充,一般为0值,也称之为空洞。第9位到第位为第二个字段B.

       第三个字段类型是string,对齐值是8,大小为,所以他的内存偏移值必须是8的倍数,因为user1前两个字段就已经排到了第位,所以下一位的偏移量正好是,正好是字段C的对齐值的倍数,不用填充,可以直接排列第三个字段,也就是从第位到位第三个字段C.

       第三个字段类型是bool,对齐值是1,大小为1,所以他的内存偏移值必须是1的倍数,因为user1前两个字段就已经排到了第位,所以下一位的偏移量正好是。正好是字段D的对齐值的倍数,不用填充,可以直接排列到第四个字段,也就是从到第位是第三个字段D.

       好了现在第一条内存对齐规则后,内存长度已经为字节,我们开始使用内存的第2条规则进行对齐。根据第二条规则,默认对齐值是8,字段中最大类型程度是,取最小的那一个,所以求出结构体的对齐值是8,我们目前的内存长度是,不是8的倍数,所以需要补齐,所以最终的结果就是,补了7位。

       说了这么多,画个图看一下吧:

       现在你们应该懂了吧,按照这个思路再去分析其他两个struct吧,这里就不再分析了。

       对于内存对齐这里还有一最后需要注意的知识点,空struct不占用任何存储空间,空 struct{ } 大小为 0,作为其他 struct 的字段时,一般不需要内存对齐。但是有一种情况除外:即当 struct{ } 作为结构体最后一个字段时,需要内存对齐。因为如果有指针指向该字段, 返回的地址将在结构体之外,如果此指针一直存活不释放对应的内存,就会有内存泄露的问题(该内存不因结构体释放而释放)。来看一个例子:

func Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr3

       简单来说,对于任何占用0大小空间的类型,像struct { }或者[0]byte这些,如果该类型出现在结构体末尾,那么我们就假设它占用1个字节的大小。因此对于test1结构体,他看起来就是这样:`

func Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr4

       因此在内存对齐时,最后结构体占用的字节就是8了。

       重点要注意的问题:不要在结构体定义的最后添加零大小的类型

总结

       好啦,终于又到文章的末尾了,我们来简单的总结一下,unsafe 包绕过了 Go 的类型系统,达到直接操作内存的目的,使用它有一定的风险性。但是在某些场景下,使用 unsafe 包提供的函数会提升代码的效率,Go 源码中也是大量使用 unsafe 包。

       unsafe 包定义了 Pointer 和三个函数:

type ArbitraryType inttype Pointer *ArbitraryTypefunc Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr

       uintptr 可以和 unsafe.Pointer 进行相互转换,uintptr 可以进行数学运算。这样,通过 uintptr 和 unsafe.Pointer 的结合就解决了 Go 指针不能进行数学运算的限制。通过 unsafe 相关函数,可以获取结构体私有成员的地址,进而对其做进一步的读写操作,突破 Go 的类型安全限制。

       最后我们又学习了内存对齐的知识,这样设计可以减少CPU访问内存的次数,加大CPU访问内存的吞吐量,所以结构体中字段合理的排序可以更节省内存,注意:不要在结构体定义的最后添加零大小的类型。

原文:/post/

       好啦,这篇文章就到这里啦,素质三连(分享、点赞、在看)都是笔者持续创作更多优质内容的动力!

       创建了一个Golang学习交流群,欢迎各位大佬们踊跃入群,我们一起学习交流。入群方式:加我vx拉你入群,或者公众号获取入群二维码

       结尾给大家发一个小福利吧,最近我在看[微服务架构设计模式]这一本书,讲的很好,自己也收集了一本PDF,有需要的小伙可以到自行下载。获取方式:关注公众号:[Golang梦工厂],后台回复:[微服务],即可获取。

       我翻译了一份GIN中文文档,会定期进行维护,有需要的小伙伴后台回复[gin

Spring Boot + EasyExcel导入导出,简直太好用了!

       老项目主要采用的POI框架来进行Excel数据的导入和导出,但经常会出现OOM的情况,导致整个服务不可用。后续逐步转移到EasyExcel,简直不能太好用了。

       EasyExcel是阿里巴巴开源插件之一,主要解决了poi框架使用复杂,sax解析模式不容易操作,数据量大起来容易OOM,解决了POI并发造成的报错。主要解决方式:通过解压文件的方式加载,一行一行地加载,并且抛弃样式字体等不重要的数据,降低内存的占用。

       在之前专门写过一篇文章《EasyExcel太方便易用了,强烈推荐!》,介绍EasyExcel功能的基本使用。今天这篇文章,我们基于SpringBoot来实现一下EasyExcel的集成,更加方便大家在实践中的直接使用。

       创建一个基础的SpringBoot项目,比如这里采用SpringBoot 2.7.2版本。

       EasyExcel在SpringBoot的集成非常方便,只需引入对应的pom依赖即可。在上述dependencies中添加EasyExcel的依赖:

       EasyExcel目前稳定最新版本2.2.。如果想查看开源项目或最新版本,可在GitHub上获得:github.com/alibaba/easy...

       为了方便和简化代码编写,这里同时引入了Lombok的依赖,后续代码中也会使用对应的注解。

       下面正式开始业务相关代码的编写。如果你想直接获得完整源码,对照源码阅读本篇文章,可在公号「程序新视界」内回“”获得完整源码。

       这里创建一个Member,会员的实体类,并在实体类中填写基础的个人信息。

       为了尽量多的演示EasyExcel的相关功能,在上述实体类中使用了其常见的一些注解:

       GenderConverter转换器的代码实现如下:

       不同版本中,convertToJavaData和convertToExcelData的方法参数有所不同,对应的值的获取方式也不同,大家在使用时注意对照自己的版本即可。

       为方便验证功能,DAO层的逻辑便不再实现,直接通过Service层来封装数据,先来看导出功能的业务类实现。

       定义MemberService接口:

       定义MemberServiceImpl实现类:

       其中数据采用模拟的静态数据,返回Member列表。

       在Controller层的实现一个简单的导出实现:

       这个实现方式非常简单直接,使用EasyExcel的write方法将查询到的数据进行处理,以流的形式写出即可。

       在浏览器访问对应的链接,可下载到如下Excel内容:

       如果我们需要将导出的Excel进行一些格式化的处理,这就需要用到导出策略的实现了。

       在EasyExcel执行write方法之后,获得ExcelWriterBuilder类,通过该类的registerWriteHandler方法可以设置一些处理策略。

       这里先实现一个通用的格式策略工具类CommonCellStyleStrategy:

       该类中示例设置了Excel的基础格式。

       再来实现一个精细化控制单元格内容CellWriteHandler的实现类:

       在这里,对单元格表头的第0个Cell设置了一个超链接。

       通过上面的定义两个策略实现,在导出Excel可以使用上述两个策略实现:

       通过浏览器,访问上述接口,导出的Excel格式如下:

       可以看出,导出的Excel已经附带了具体的格式。其中表头“用户名”上也携带了对应的超链接。其他更精细化的控制,大家可以在策略类中做进一步的控制。

       所谓的同步获取结果导入,就是执行导入操作时,将导入内容解析封装成一个结果列表返回给业务,业务代码再对列表中的数据进行集中的处理。

       先来看同步导入的实现方式。

       注意,在上述代码中,最终调用的是doReadSync()方法。

       这里直接用PostMan进行相应的文件上传请求:

       执行导入请求,会发现控制台打印出对应的解析对象:

       说明上传成功,并且解析成功。

       上面示例中是基于同步获取结果列表的形式进行导入,还有一种实现方式是基于监听器的形式来实现。这种形式可以达到边解析边处理业务逻辑的效果。

       定义Listener:

       在MemberExcelListener中可以针对每条数据进行对应的业务逻辑处理。

       对外接口实现如下:

       这里采用了doRead()方法进行读取操作。在PostMan中再次上传Excel,打印日志如下:

       说明解析成功,并且在解析的过程中,进行了业务逻辑的处理。

       本篇文章基于SpringBoot集成EasyExcel的实现展开,为大家讲解了EasyExcel在实践中的具体运用。大家可根据需要,进行变通处理。同时,基于自定义转换器、自定义策略、自定义监听器等形式达到灵活适用于各种场景。希望本篇文章能给大家带来帮助。

       博主简介:《SpringBoot技术内幕》技术图书作者,酷爱钻研技术,写技术干货文章。 公众号:「程序新视界」,博主的公众号,欢迎关注~ 技术交流:请联系博主微信号:zhuan2quan

vue-srr 实现原理( vuex、vue-router、syncData )

       服务端渲染(SSR)是一种从服务器返回预渲染的HTML页面的技术,适用于PHP、JSP、Node.js等服务器端框架。它与传统的Vue单页面应用(SPA)不同,在SPA中,页面的渲染是由JavaScript完成的,服务器仅返回一个包含单个div和script标签的HTML文件,其余DOM结构由bundle.js生成并挂载到div中。这种情况下,搜索引擎爬虫难以抓取页面内容,对于SEO重要的网站,使用SSR能解决此问题。

       SSR的基本使用包括启动服务器、返回HTML文档。我们通常使用Express作为服务端框架。在实际应用中,通过运行服务器并在本地浏览器访问服务器地址查看源代码,可看到服务端返回的HTML内容。

       在Vue中实现SSR,核心是通过`vue-server-renderer`库将Vue对象转换成字符串返回给客户端。这样,一个简单的Vue-SSR实现就完成了。

       为了更好地组织代码,可以采用模块化方式。首先创建`app.js`作为入口文件,`client-entry.js`用于服务端渲染后客户端激活,而`server-entry.js`用于服务端渲染。这里需要返回一个工厂函数,确保每次访问服务端都是全新的Vue实例。

       接着,创建`index.template.html`,服务端会将`server-entry.js`中的Vue对象通过`vue-server-renderer`解析成字符串放置在这里。打包客户端和服务器端代码的逻辑由`webpack`负责,包括配置文件如`webpack.base.config.js`、`webpack.client.config.js`、`webpack.server.config.js`等。

       最后,通过`server.js`实现服务端渲染逻辑。使用`vue-server-renderer`生成的HTML字符串被返回给客户端。当前实现尚未支持`vue-router`和状态管理`vuex`,需要进行代码调整以支持这些特性。

       在`src`目录下创建`router`和`store`文件夹,分别用于`vue-router`和`vuex`的配置,以便在服务端使用。对`app.js`、`server-entry.js`、`client-entry.js`和`server.js`进行相应改造,以整合`vue-router`和`vuex`支持。

       Vue-SSR本质上是通过`webpack`打包`client-entry.js`和`server-entry.js`,首次页面加载时,通过`vue-server-renderer`将`server-entry.js`中的Vue实例生成字符串返回给客户端渲染,后续通过`client-entry.js`进行客户端激活。客户端激活指的是Vue在浏览器端接管静态HTML,使其变为由Vue管理的动态DOM。

       整个Vue-SSR实现和代码示例可以在GitHub仓库`github.com/zenghao/...`中找到。

Go并发编程:goroutine,channel和sync详解

       ä¼˜é›…的并发编程范式,完善的并发支持,出色的并发性能是Go语言区别于其他语言的一大特色。

       åœ¨å½“今这个多核时代,并发编程的意义不言而喻。使用Go开发并发程序,操作起来非常简单,语言级别提供关键字go用于启动协程,并且在同一台机器上可以启动成千上万个协程。

       ä¸‹é¢å°±æ¥è¯¦ç»†ä»‹ç»ã€‚

goroutine

       Go语言的并发执行体称为goroutine,使用关键词go来启动一个goroutine。

       go关键词后面必须跟一个函数,可以是有名函数,也可以是无名函数,函数的返回值会被忽略。

       go的执行是非阻塞的。

       å…ˆæ¥çœ‹ä¸€ä¸ªä¾‹å­ï¼š

packagemainimport("fmt""time")funcmain(){ gospinner(*time.Millisecond)constn=fibN:=fib(n)fmt.Printf("\rFibonacci(%d)=%d\n",n,fibN)//Fibonacci()=}funcspinner(delaytime.Duration){ for{ for_,r:=range`-\|/`{ fmt.Printf("\r%c",r)time.Sleep(delay)}}}funcfib(xint)int{ ifx<2{ returnx}returnfib(x-1)+fib(x-2)}

       ä»Žæ‰§è¡Œç»“果来看,成功计算出了斐波那契数列的值,说明程序在spinner处并没有阻塞,而且spinner函数还一直在屏幕上打印提示字符,说明程序正在执行。

       å½“计算完斐波那契数列的值,main函数打印结果并退出,spinner也跟着退出。

       å†æ¥çœ‹ä¸€ä¸ªä¾‹å­ï¼Œå¾ªçŽ¯æ‰§è¡Œæ¬¡ï¼Œæ‰“印两个数的和:

packagemainimport"fmt"funcAdd(x,yint){ z:=x+yfmt.Println(z)}funcmain(){ fori:=0;i<;i++{ goAdd(i,i)}}

       æœ‰é—®é¢˜äº†ï¼Œå±å¹•ä¸Šä»€ä¹ˆéƒ½æ²¡æœ‰ï¼Œä¸ºä»€ä¹ˆå‘¢ï¼Ÿ

       è¿™å°±è¦çœ‹Go程序的执行机制了。当一个程序启动时,只有一个goroutine来调用main函数,称为主goroutine。新的goroutine通过go关键词创建,然后并发执行。当main函数返回时,不会等待其他goroutine执行完,而是直接暴力结束所有goroutine。

       é‚£æœ‰æ²¡æœ‰åŠžæ³•è§£å†³å‘¢ï¼Ÿå½“然是有的,请往下看。

channel

       ä¸€èˆ¬å†™å¤šè¿›ç¨‹ç¨‹åºæ—¶ï¼Œéƒ½ä¼šé‡åˆ°ä¸€ä¸ªé—®é¢˜ï¼šè¿›ç¨‹é—´é€šä¿¡ã€‚常见的通信方式有信号,共享内存等。goroutine之间的通信机制是通道channel。

       ä½¿ç”¨make创建通道:

ch:=make(chanint)//ch的类型是chanint

       é€šé“支持三个主要操作:send,receive和close。

ch<-x//发送x=<-ch//接收<-ch//接收,丢弃结果close(ch)//关闭无缓冲channel

       make函数接受两个参数,第二个参数是可选参数,表示通道容量。不传或者传0表示创建了一个无缓冲通道。

       æ— ç¼“冲通道上的发送操作将会阻塞,直到另一个goroutine在对应的通道上执行接收操作。相反,如果接收先执行,那么接收goroutine将会阻塞,直到另一个goroutine在对应通道上执行发送。

       æ‰€ä»¥ï¼Œæ— ç¼“冲通道是一种同步通道。

       ä¸‹é¢æˆ‘们使用无缓冲通道把上面例子中出现的问题解决一下。

packagemainimport"fmt"funcAdd(x,yint,chchanint){ z:=x+ych<-z}funcmain(){ ch:=make(chanint)fori:=0;i<;i++{ goAdd(i,i,ch)}fori:=0;i<;i++{ fmt.Println(<-ch)}}

       å¯ä»¥æ­£å¸¸è¾“出结果。

       ä¸»goroutine会阻塞,直到读取到通道中的值,程序继续执行,最后退出。

缓冲channel

       åˆ›å»ºä¸€ä¸ªå®¹é‡æ˜¯5的缓冲通道:

ch:=make(chanint,5)

       ç¼“冲通道的发送操作在通道尾部插入一个元素,接收操作从通道的头部移除一个元素。如果通道满了,发送会阻塞,直到另一个goroutine执行接收。相反,如果通道是空的,接收会阻塞,直到另一个goroutine执行发送。

       æœ‰æ²¡æœ‰æ„Ÿè§‰ï¼Œå…¶å®žç¼“冲通道和队列一样,把操作都解耦了。

单向channel

       ç±»åž‹chan<-int是一个只能发送的通道,类型<-chanint是一个只能接收的通道。

       ä»»ä½•åŒå‘通道都可以用作单向通道,但反过来不行。

       è¿˜æœ‰ä¸€ç‚¹éœ€è¦æ³¨æ„ï¼Œclose只能用在发送通道上,如果用在接收通道会报错。

       çœ‹ä¸€ä¸ªå•å‘通道的例子:

packagemainimport"fmt"funccounter(outchan<-int){ forx:=0;x<;x++{ out<-x}close(out)}funcsquarer(outchan<-int,in<-chanint){ forv:=rangein{ out<-v*v}close(out)}funcprinter(in<-chanint){ forv:=rangein{ fmt.Println(v)}}funcmain(){ n:=make(chanint)s:=make(chanint)gocounter(n)gosquarer(s,n)printer(s)}sync

       sync包提供了两种锁类型:sync.Mutex和sync.RWMutex,前者是互斥锁,后者是读写锁。

       å½“一个goroutine获取了Mutex后,其他goroutine不管读写,只能等待,直到锁被释放。

packagemainimport("fmt""sync""time")funcmain(){ varmutexsync.Mutexwg:=sync.WaitGroup{ }//主goroutine先获取锁fmt.Println("Locking(G0)")mutex.Lock()fmt.Println("locked(G0)")wg.Add(3)fori:=1;i<4;i++{ gofunc(iint){ //由于主goroutine先获取锁,程序开始5秒会阻塞在这里fmt.Printf("Locking(G%d)\n",i)mutex.Lock()fmt.Printf("locked(G%d)\n",i)time.Sleep(time.Second*2)mutex.Unlock()fmt.Printf("unlocked(G%d)\n",i)wg.Done()}(i)}//主goroutine5秒后释放锁time.Sleep(time.Second*5)fmt.Println("readyunlock(G0)")mutex.Unlock()fmt.Println("unlocked(G0)")wg.Wait()}

       RWMutex属于经典的单写多读模型,当读锁被占用时,会阻止写,但不阻止读。而写锁会阻止写和读。

packagemainimport("fmt""sync""time")funcmain(){ varrwMutexsync.RWMutexwg:=sync.WaitGroup{ }Data:=0wg.Add()fori:=0;i<;i++{ gofunc(tint){ //第一次运行后,写解锁。//循环到第二次时,读锁定后,goroutine没有阻塞,同时读成功。fmt.Println("Locking")rwMutex.RLock()deferrwMutex.RUnlock()fmt.Printf("Readdata:%v\n",Data)wg.Done()time.Sleep(2*time.Second)}(i)gofunc(tint){ //写锁定下是需要解锁后才能写的rwMutex.Lock()deferrwMutex.Unlock()Data+=tfmt.Printf("WriteData:%v%d\n",Data,t)wg.Done()time.Sleep(2*time.Second)}(i)}wg.Wait()}总结

       å¹¶å‘编程算是Go的特色,也是核心功能之一了,涉及的知识点其实是非常多的,本文也只是起到一个抛砖引玉的作用而已。

       æœ¬æ–‡å¼€å§‹ä»‹ç»äº†goroutine的简单用法,然后引出了通道的概念。

       é€šé“有三种:

       æ— ç¼“冲通道

       ç¼“冲通道

       å•å‘通道

       æœ€åŽä»‹ç»äº†Go中的锁机制,分别是sync包提供的sync.Mutex(互斥锁)和sync.RWMutex(读写锁)。

       goroutine博大精深,后面的坑还是要慢慢踩的。

       æ–‡ç« ä¸­çš„脑图和源码都上传到了GitHub,有需要的同学可自行下载。

       åœ°å€ï¼šgithub.com/yongxinz/gopher/tree/main/sc

       ä½œè€…:yongxinz