github/goSTL
1
0
Fork 0
mirror of https://github.com/hlccd/goSTL.git synced 2025-01-18 22:09:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Delete goSTL/algorithm directory

Browse Source
This commit is contained in:
hlccd 2021-12-29 00:25:04 +08:00 committed by GitHub
parent 77fa7730c1
commit a1bf36eadc
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 0 additions and 426 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

107
goSTL/algorithm/algorithm/hash.go
View File

@ -1,107 +0,0 @@
package algorithm
//@Title algorithm
//@Description
// hash函数
// 定义了一个hash函数类型,该类型可传入一个key并返回其hash值
// 该包内定义了一些自带类型的hash函数
// 当使用自定义的数据结构时若不传入hash函数则使用默认的hash函数
// 若传入类型非系统自带类型,则返回nil同时对数据的插入失败
type Hasher func(key interface{}) uint64
func GetHash(e interface{}) (hash Hasher) {
if e == nil {
return nil
}
switch e.(type) {
case bool:
return boolHash
case int:
return intHash
case int8:
return int8Hash
case uint8:
return uint8Hash
case int16:
return int16Hash
case uint16:
return uint16Hash
case int32:
return int32Hash
case uint32:
return uint32Hash
case int64:
return int64Hash
case uint64:
return uint64Hash
case float32:
return float32Hash
case float64:
return float64Hash
case complex64:
return complex64Hash
case complex128:
return complex128Hash
case string:
return stringHash
}
return nil
}
func boolHash(key interface{}) uint64 {
if key.(bool) {
return 1
}
return 0
}
func intHash(key interface{}) uint64 {
return uint64(key.(int) * key.(int) / 2)
}
func int8Hash(key interface{}) uint64 {
return uint64(key.(int8) * key.(int8) / 2)
}
func uint8Hash(key interface{}) uint64 {
return uint64(key.(uint8) * key.(uint8) / 2)
}
func int16Hash(key interface{}) uint64 {
return uint64(key.(int16) * key.(int16) / 2)
}
func uint16Hash(key interface{}) uint64 {
return uint64(key.(uint16) * key.(uint16) / 2)
}
func int32Hash(key interface{}) uint64 {
return uint64(key.(int32) * key.(int32) / 2)
}
func uint32Hash(key interface{}) uint64 {
return uint64(key.(uint32) * key.(uint32) / 2)
}
func int64Hash(key interface{}) uint64 {
return uint64(key.(int64) * key.(int64) / 2)
}
func uint64Hash(key interface{}) uint64 {
return uint64(key.(uint64) * key.(uint64) / 2)
}
func float32Hash(key interface{}) uint64 {
return uint64(key.(float32) * key.(float32) / 2)
}
func float64Hash(key interface{}) uint64 {
return uint64(key.(float64) * key.(float64) / 2)
}
func complex64Hash(key interface{}) uint64 {
r := uint64(real(key.(complex64)))
i := uint64(imag(key.(complex64)))
return uint64Hash(r) + uint64Hash(i)
}
func complex128Hash(key interface{}) uint64 {
r := uint64(real(key.(complex64)))
i := uint64(imag(key.(complex64)))
return uint64Hash(r) + uint64Hash(i)
}
func stringHash(key interface{}) uint64 {
bs := []byte(key.(string))
ans := uint64(0)
for i := range bs {
ans += uint64(bs[i] * 251)
}
return ans
}

106
goSTL/algorithm/algorithm/singleFlight/singleFlight.go
View File

@ -1,106 +0,0 @@
package singleFlight
//@Title singleFlight
//@Description
// 单次请求-single flight
// 利用可重入锁避免对于一个同类的请求进行多次从而导致的缓存击穿的问题
// 缓存击穿：
// 缓存在某个时间点过期的时候
// 恰好在这个时间点对这个Key有大量的并发请求过来
// 这些请求发现缓存过期一般都会从后端DB加载数据并回设到缓存
// 这个时候大并发的请求可能会瞬间把后端DB压垮。
import "sync"
//呼叫请求结构体
type call struct {
wg sync.WaitGroup //可重入锁
val interface{} //请求结果
err error //错误反馈
}
//一组请求工作
//每一类请求对应一个call,利用其内部的可重入锁避免一类请求在短时间内频繁执行
//请求组工作由使用者自行分配空间来实现
type Group struct {
m map[string]*call //一类请求与同一类呼叫的映射表
mu sync.Mutex //并发控制锁,保证线程安全
}
//@title Do
//@description
// 以请求做做接收者
// 传入一个请求类的key和请求调用函数fn
// 请求时候需要等待之前有的同类请求先完成在进行
// 防止击穿缓存,对同一个key进行请求时需要分别进行,利用可重入锁实现
// 请求完成后返回结果和错误信息即可
//@receiver g *Group 接受者请求组的指针
//@param key string 请求的关键词key
//@param fn func() (interface{}, error) 请求执行函数
//@return v interface{} 请求执行得到的结果
//@return err error 执行请求后的错误信息
func (g *Group) Do(key string, fn func() (interface{}, error)) (v interface{}, err error) {
g.mu.Lock()
if g.m == nil {
g.m = make(map[string]*call)
}
//判断以key为关键词的该类请求是否存在
if c, ok := g.m[key]; ok {
g.mu.Unlock()
// 如果请求正在进行中，则等待
c.wg.Wait()
return c.val, c.err
}
//该类请求不存在,创建个请求
c := new(call)
// 发起请求前加锁,并将请求添加到请求组内以表示该类请求正在处理
c.wg.Add(1)
g.m[key] = c
g.mu.Unlock()
//调用请求函数获取内容
c.val, c.err = fn()
//请求结束
c.wg.Done()
g.mu.Lock()
//从请求组中删除该呼叫请求
delete(g.m, key)
g.mu.Unlock()
return c.val, c.err
}
//@title hash
//@description
// 以请求做做接收者
// 传入一个请求类的key和请求调用函数fn
// 请求时候需要等待之前有的同类请求先完成在进行
// 防止击穿缓存,对同一个key进行请求时需要分别进行,利用可重入锁实现
// 返回一个channel,利用fn函数获取到的数据将会传入其中
// 可利用channel做超时控制
//@receiver g *Group 接受者请求组的指针
//@param key string 请求的关键词key
//@param fn func() (interface{}, error) 请求执行函数
//@return ch chan interface{} 执行结果将会传入其中,可做超时控制
func (g *Group) DoChan(key string, fn func() (interface{}, error)) (ch chan interface{}) {
ch = make(chan interface{}, 1)
g.mu.Lock()
if g.m == nil {
g.m = make(map[string]*call)
}
if _, ok := g.m[key]; ok {
g.mu.Unlock()
return ch
}
c := new(call)
c.wg.Add(1) // 发起请求前加锁
g.m[key] = c // 添加到 g.m，表明 key 已经有对应的请求在处理
g.mu.Unlock()
go func() {
c.val, c.err = fn() // 调用 fn，发起请求
c.wg.Done() // 请求结束
g.mu.Lock()
delete(g.m, key) // 更新 g.m
ch <- c.val
g.mu.Unlock()
}()
return ch
}

107
goSTL/algorithm/hash.go
View File

@ -1,107 +0,0 @@
package algorithm
//@Title algorithm
//@Description
// hash函数
// 定义了一个hash函数类型,该类型可传入一个key并返回其hash值
// 该包内定义了一些自带类型的hash函数
// 当使用自定义的数据结构时若不传入hash函数则使用默认的hash函数
// 若传入类型非系统自带类型,则返回nil同时对数据的插入失败
type Hasher func(key interface{}) uint64
func GetHash(e interface{}) (hash Hasher) {
if e == nil {
return nil
}
switch e.(type) {
case bool:
return boolHash
case int:
return intHash
case int8:
return int8Hash
case uint8:
return uint8Hash
case int16:
return int16Hash
case uint16:
return uint16Hash
case int32:
return int32Hash
case uint32:
return uint32Hash
case int64:
return int64Hash
case uint64:
return uint64Hash
case float32:
return float32Hash
case float64:
return float64Hash
case complex64:
return complex64Hash
case complex128:
return complex128Hash
case string:
return stringHash
}
return nil
}
func boolHash(key interface{}) uint64 {
if key.(bool) {
return 1
}
return 0
}
func intHash(key interface{}) uint64 {
return uint64(key.(int) * key.(int) / 2)
}
func int8Hash(key interface{}) uint64 {
return uint64(key.(int8) * key.(int8) / 2)
}
func uint8Hash(key interface{}) uint64 {
return uint64(key.(uint8) * key.(uint8) / 2)
}
func int16Hash(key interface{}) uint64 {
return uint64(key.(int16) * key.(int16) / 2)
}
func uint16Hash(key interface{}) uint64 {
return uint64(key.(uint16) * key.(uint16) / 2)
}
func int32Hash(key interface{}) uint64 {
return uint64(key.(int32) * key.(int32) / 2)
}
func uint32Hash(key interface{}) uint64 {
return uint64(key.(uint32) * key.(uint32) / 2)
}
func int64Hash(key interface{}) uint64 {
return uint64(key.(int64) * key.(int64) / 2)
}
func uint64Hash(key interface{}) uint64 {
return uint64(key.(uint64) * key.(uint64) / 2)
}
func float32Hash(key interface{}) uint64 {
return uint64(key.(float32) * key.(float32) / 2)
}
func float64Hash(key interface{}) uint64 {
return uint64(key.(float64) * key.(float64) / 2)
}
func complex64Hash(key interface{}) uint64 {
r := uint64(real(key.(complex64)))
i := uint64(imag(key.(complex64)))
return uint64Hash(r) + uint64Hash(i)
}
func complex128Hash(key interface{}) uint64 {
r := uint64(real(key.(complex64)))
i := uint64(imag(key.(complex64)))
return uint64Hash(r) + uint64Hash(i)
}
func stringHash(key interface{}) uint64 {
bs := []byte(key.(string))
ans := uint64(0)
for i := range bs {
ans += uint64(bs[i] * 251)
}
return ans
}

106
goSTL/algorithm/singleFlight/singleFlight.go
View File

@ -1,106 +0,0 @@
package singleFlight
//@Title singleFlight
//@Description
// 单次请求-single flight
// 利用可重入锁避免对于一个同类的请求进行多次从而导致的缓存击穿的问题
// 缓存击穿：
// 缓存在某个时间点过期的时候
// 恰好在这个时间点对这个Key有大量的并发请求过来
// 这些请求发现缓存过期一般都会从后端DB加载数据并回设到缓存
// 这个时候大并发的请求可能会瞬间把后端DB压垮。
import "sync"
//呼叫请求结构体
type call struct {
wg sync.WaitGroup //可重入锁
val interface{} //请求结果
err error //错误反馈
}
//一组请求工作
//每一类请求对应一个call,利用其内部的可重入锁避免一类请求在短时间内频繁执行
//请求组工作由使用者自行分配空间来实现
type Group struct {
m map[string]*call //一类请求与同一类呼叫的映射表
mu sync.Mutex //并发控制锁,保证线程安全
}
//@title Do
//@description
// 以请求做做接收者
// 传入一个请求类的key和请求调用函数fn
// 请求时候需要等待之前有的同类请求先完成在进行
// 防止击穿缓存,对同一个key进行请求时需要分别进行,利用可重入锁实现
// 请求完成后返回结果和错误信息即可
//@receiver g *Group 接受者请求组的指针
//@param key string 请求的关键词key
//@param fn func() (interface{}, error) 请求执行函数
//@return v interface{} 请求执行得到的结果
//@return err error 执行请求后的错误信息
func (g *Group) Do(key string, fn func() (interface{}, error)) (v interface{}, err error) {
g.mu.Lock()
if g.m == nil {
g.m = make(map[string]*call)
}
//判断以key为关键词的该类请求是否存在
if c, ok := g.m[key]; ok {
g.mu.Unlock()
// 如果请求正在进行中，则等待
c.wg.Wait()
return c.val, c.err
}
//该类请求不存在,创建个请求
c := new(call)
// 发起请求前加锁,并将请求添加到请求组内以表示该类请求正在处理
c.wg.Add(1)
g.m[key] = c
g.mu.Unlock()
//调用请求函数获取内容
c.val, c.err = fn()
//请求结束
c.wg.Done()
g.mu.Lock()
//从请求组中删除该呼叫请求
delete(g.m, key)
g.mu.Unlock()
return c.val, c.err
}
//@title hash
//@description
// 以请求做做接收者
// 传入一个请求类的key和请求调用函数fn
// 请求时候需要等待之前有的同类请求先完成在进行
// 防止击穿缓存,对同一个key进行请求时需要分别进行,利用可重入锁实现
// 返回一个channel,利用fn函数获取到的数据将会传入其中
// 可利用channel做超时控制
//@receiver g *Group 接受者请求组的指针
//@param key string 请求的关键词key
//@param fn func() (interface{}, error) 请求执行函数
//@return ch chan interface{} 执行结果将会传入其中,可做超时控制
func (g *Group) DoChan(key string, fn func() (interface{}, error)) (ch chan interface{}) {
ch = make(chan interface{}, 1)
g.mu.Lock()
if g.m == nil {
g.m = make(map[string]*call)
}
if _, ok := g.m[key]; ok {
g.mu.Unlock()
return ch
}
c := new(call)
c.wg.Add(1) // 发起请求前加锁
g.m[key] = c // 添加到 g.m，表明 key 已经有对应的请求在处理
g.mu.Unlock()
go func() {
c.val, c.err = fn() // 调用 fn，发起请求
c.wg.Done() // 请求结束
g.mu.Lock()
delete(g.m, key) // 更新 g.m
ch <- c.val
g.mu.Unlock()
}()
return ch
}