go 代码片段

已于 2024-06-20 17:01:03 修改
阅读量350 收藏 9
点赞数 11
文章标签： golang 开发语言 后端
于 2023-12-19 11:19:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zydbk/article/details/135078060
版权

1、多协程顺序打印A、B、C

//（1）使用channel控制打印次数


func main() {
	var wg sync.WaitGroup
	wg.Add(3)
	a := make(chan bool, 1)
	b := make(chan bool, 1)
	c := make(chan bool, 1)
	flag := make(chan int, 1)
	flag <- 0
	a <- true
	defer cancel()
	go func() {
		defer func() {
			wg.Done()
		}()
		for {
			select {
			case <- a:
				f := <- flag
				if  f > 10 {
					wg.Done()
					wg.Done()
					return
				} else {
					flag <- f + 1
					fmt.Println(f)
				}
				fmt.Println("A")
				b <- true
			}
		}
	}()
	go func() {
		defer func() {
			wg.Done()
		}()
		for {
			select {
			case <- b:
				f := <- flag
				if f > 10 {
					wg.Done()
					wg.Done()
					return
				} else {
					flag <- f + 1
					fmt.Println(f)
				}
				fmt.Println("B")
				c <- true
			}
		}
	}()
	go func() {
		defer func() {
			wg.Done()
		}()
		for {
			select {
			case <- c:
				f := <- flag
				if f > 10 {
					wg.Done()
					wg.Done()
					return
				} else {
					flag <- f + 1
					fmt.Println(f)
				}
				fmt.Println("C")
				a <- true
			}
		}
	}()
	wg.Wait()
	return
}

（2）使用atomic原子锁控制打印次数

func main() {
	var wg sync.WaitGroup
	wg.Add(3)
	var count int32
	a := make(chan bool, 1)
	b := make(chan bool, 1)
	c := make(chan bool, 1)
	a <- true
	go func() {
		defer func() {
			wg.Done()
		}()
		for count < 10 {
			atomic.AddInt32(&count, 1)
			<- a
			fmt.Println("A")
			b <- true
		}
	}()
	go func() {
		defer func() {
			wg.Done()
		}()
		for count < 10 {
			atomic.AddInt32(&count, 1)
			<- b
			fmt.Println("B")
			c <- true
		}
	}()
	go func() {
		defer func() {
			wg.Done()
		}()
		for count < 10 {
			atomic.AddInt32(&count, 1)
			<- c
			fmt.Println("C")
			a <- true
		}
	}()
	wg.Wait()

	return
}

（3）使用context控制打印时长

func main() {
	var wg sync.WaitGroup
	wg.Add(3)
	a := make(chan bool, 1)
	b := make(chan bool, 1)
	c := make(chan bool, 1)
	a <- true
	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, time.Second * 1)
	defer cancel()
	go func() {
		defer func() {
			wg.Done()
		}()
		for {
			select {
			case <-ctx.Done():
				return
			default:
				<-a
				fmt.Println("A")
				b <- true
			}
		}
	}()
	go func() {
		defer func() {
			wg.Done()
		}()
		for {
			select {
			case <-ctx.Done():
				return
			default:
				<- b
				fmt.Println("B")
				c <- true
			}
		}
	}()
	go func() {
		defer func() {
			wg.Done()
		}()
		for {
			select {
			case <-ctx.Done():
				return
			default:
				<- c
				fmt.Println("C")
				a <- true
			}
		}
	}()
	wg.Wait()
	return
}

2. 接口限流的常见做法

（1）固定窗口: 在一定时间内设置处理次数上限，定时重置

package main

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

type FixedWindow struct {
	size        time.Duration // 窗口大小
	maxRequests int           // 最大请求数
	requests    int           // 当前窗口内的请求数
	lastReset   int64         // 上次窗口重置时间（秒级时间戳）
	mutex       sync.Mutex    // 重置锁
}

func NewFixedWindow(size time.Duration, maxRequests int) *FixedWindow {
	return &FixedWindow{
		size:        size,
		maxRequests: maxRequests,
		lastReset:   time.Now().Unix(),
	}
}

func(window *FixedWindow) AllowRequest(ctx context.Context, now time.Time) bool {
	window.mutex.Lock()
	defer window.mutex.Unlock()

	for{
		select {
		case <- ctx.Done():
			return false
		default:
			// 时间间隔是否满足重置条件
			if now.Unix() - window.lastReset >= int64(window.size.Seconds()) {
				window.requests = 0
				window.lastReset = now.Unix()
			}
			// 窗口内请求数是否超过最大值
			if window.requests >= window.maxRequests {
				return false
			}
			window.requests++
			return  true
		}
	}
}

func main() {
	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, time.Second * 2)
	defer cancel()
	window := NewFixedWindow(time.Second * 1,5)
	for {
		select {
		case <-ctx.Done():
			return
		default:
			now := time.Now()
			format := now.Format("15:04:05.0000000")
			if window.AllowRequest(ctx, now) {
				fmt.Println(format + " 请求已执行")
			} else {
				fmt.Println(format + " 请求被限流，无法执行")
			}
			time.Sleep(100 * time.Millisecond)
		}
	}
}

（2）滑动窗口：设定单位时间内请求数上限，清除不在窗口内的请求

package main

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

type slidingWindow struct {
	size        time.Duration // 窗口大小
	maxRequests int           // 最大请求数
	requests    []time.Time   // 当前窗口内的请求时间
	mutex       sync.Mutex    // 请求锁
}

func NewSlidingWindow(windowSize time.Duration, maxRequests int) *slidingWindow {
	return &slidingWindow{
		size:  windowSize,
		maxRequests: maxRequests,
		requests:    make([]time.Time, 0),
	}
}

func (window *slidingWindow) AllowRequest(ctx context.Context, now time.Time) bool {
	window.mutex.Lock()
	defer window.mutex.Unlock()
    for{
		select {
		case <- ctx.Done():
			return false
		default:
			// 移除不在窗口时间内的请求
			for len(window.requests) > 0 && now.Sub(window.requests[0]) > window.size {
				window.requests = window.requests[1:]
			}

			// 窗口内请求数是否超过最大值
			if len(window.requests) >= window.maxRequests {
				return false
			}

			window.requests = append(window.requests, now)
			return  true
		}
	}
}

func main() {
	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, 3 * time.Second)
	defer cancel()
	window := NewSlidingWindow(1 * time.Second, 4) // 每秒最多允许4个请求
	for{
		select {
		case <- ctx.Done():
			return
		default:
			now := time.Now()
			format :=  now.Format("15:04:05.0000000")
			if window.AllowRequest(ctx, now) {
				fmt.Println(format + " 请求已执行")
			} else {
				fmt.Println(format + " 请求被限流，无法执行")
			}
			time.Sleep(100 * time.Millisecond)
		}
	}
}

（3）漏桶：漏桶内容量未满即可处理请求

package main

import (
	"context"
	"fmt"
	"time"
)

type LeakyBucket struct {
	rate          float64 // 漏桶速率，个/秒
	capacity      int     // 漏桶容量
	standing      int     // 桶内水量
	lastLeakyTime int64   // 上次漏水的时间戳
}

func NewLeakyBucket(rate float64, cap int) *LeakyBucket {
	return &LeakyBucket{
		rate:          rate,
		capacity:      cap,
		standing:      0,
		lastLeakyTime: time.Now().Unix(),
	}
}

// AllowRequest 检查是否处理本次请求，是就返回true，否则返回false
func (bucket *LeakyBucket) AllowRequest(ctx context.Context, now time.Time) bool {
	for {
		select {
		case <-ctx.Done():
			return false
		default:
			// 漏水，根据时间间隔计算漏掉的水量
			time := now.Unix() - bucket.lastLeakyTime
			amount := int(float64(time) * bucket.rate)
			fmt.Printf("amount: %d\n", amount)
			if amount > 0 {
				// 更新桶内水量
				bucket.standing -= amount
				if bucket.standing < 0 {
					bucket.standing = 0
				}
			}

			// 判断当前存量是否超过容量
			if bucket.standing >= bucket.capacity {
				return false
			}

			bucket.standing++
			bucket.lastLeakyTime = now.Unix()
			return true
		}
	}
}

func main() {
	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, time.Second*2)
	defer cancel()
	bucket := NewLeakyBucket(4, 5)
	for {
		select {
		case <-ctx.Done():
			return
		default:
			now := time.Now()
			format := now.Format("15:04:05.0000000")
			if bucket.AllowRequest(ctx, now) {
				fmt.Println(format + " 请求已执行")
			} else {
				fmt.Println(format + " 请求被限流，无法执行")
			}
			time.Sleep(100 * time.Millisecond)
		}
	}
}

（4）令牌桶：以固定速率向桶内补充令牌，请求到来时根据桶内令牌判断是否能处理

package main

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

type TokenBucket struct {
	rate         float64    // 令牌添加到桶中的速率，个/秒
	capacity     int        // 令牌桶容量
	standing     int        // 令牌桶内令牌数量
	lastDripTime int64      // 上次更新令牌数量的时间
	mutex        sync.Mutex // 互斥锁
}

func NewTokenBucket(rate float64, cap int) *TokenBucket {
	return &TokenBucket{
		rate:         rate,
		capacity:     cap,
		standing:     0,
		lastDripTime: time.Now().Unix(),
	}
}

// AllowRequest 检查是否可以从桶中移除一个令牌。如果可以，它移除一个令牌并返回 true。如果不可以，它返回 false。
func (bucket *TokenBucket) AllowRequest(ctx context.Context, now time.Time) bool {
	bucket.mutex.Lock()
	defer bucket.mutex.Unlock()

	for {
		select {
		case <-ctx.Done():
			return false
		default:
			// 计算从上次更新令牌数量到现在应该补充的令牌数量
			leakyNum := int(float64(now.Unix()-bucket.lastDripTime) * bucket.rate)
			if leakyNum > 0 {
				bucket.lastDripTime = now.Unix()

				bucket.standing += leakyNum
				if bucket.standing > bucket.capacity {
					bucket.standing = bucket.capacity
				}
			}

			// 判断当前是否有可以消耗的令牌
			if bucket.standing > 0 {
				bucket.standing--
				return true
			}
			return false
		}
	}

}

func main() {
	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, time.Second*2)
	defer cancel()
	bucket := NewTokenBucket(4, 5)
	for {
		select {
		case <-ctx.Done():
			return
		default:
			now := time.Now()
			format := now.Format("15:04:05.0000000")
			if bucket.AllowRequest(ctx, now) {
				fmt.Println(format + " 请求已执行")
			} else {
				fmt.Println(format + " 请求被限流，无法执行")
			}
			time.Sleep(100 * time.Millisecond)
		}
	}
}

四种算法的对比

算法优点缺点适用场景
固定窗口- 简单直观，易于实现
- 适用于稳定的流量控制
- 易于实现速率控制		.- 无法应对短时间内的突发流量
- 流量不均匀时可能导致突发流量		- 稳定的流量控制，不需要保证请求均匀分布的场景
滑动窗口- 平滑处理突发流量
- 颗粒度更小，可以提供更精确的限流控制		.- 实现相对复杂
- 需要维护滑动窗口的状态
- 存在较高的内存消耗		- 需要平滑处理突发流量的场景
漏桶- 平滑处理突发流量
- 可以固定输出速率，有效防止过载
-对突发流量的处理不够灵活		.- 对突发流量的处理不够灵活
- 无法应对流量波动的情况		- 需要固定输出速率的场景
-避免流量的突然增大对系统的冲击的场景
令牌桶- 平滑处理突发流量
- 可以动态调整限流规则
- 能适应不同时间段的流量变化		.- 实现相对复杂
- 需要维护令牌桶的状态		- 需要动态调整限流规则的场景
- 需要平滑处理突发流量的场景

todo

// 1.将容量设置为带缓冲的通道类型，起一个协程做动态补充
package main

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

type bucket struct {
	rate     float64
	standing chan int
	capacity int
}

func NewBucket(rate float64, cap int) *bucket {
	return &bucket{
		rate:     rate,
		capacity: cap,
		standing: make(chan int, cap),
	}
}

func (b *bucket) replenish(ctx context.Context, wg *sync.WaitGroup) {
	defer wg.Done()
	for {
		select {
		case <-ctx.Done():
			return
		default:
			if len(b.standing) >= b.capacity {
				return
			}
			time.Sleep(time.Second / time.Duration(b.rate))
			b.standing <- 1
			fmt.Printf("当前容量：%d\n", len(b.standing))
		}
	}
}

func main() {
	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, time.Second*2)
	defer cancel()
	b := NewBucket(2, 6)
	var wg sync.WaitGroup
	wg.Add(1)
	go b.replenish(ctx, &wg)
	wg.Wait()
}

3. 截取切片

func subSlice[S ~[]E, E any](s S, skip, limit int64) S {
	if skip == 0 && limit == 0 {
		return s
	}

	start := skip
	if start < 0 {
		start = 0
	}

	if limit < 0 {
		limit = 0
	}
	end := start + limit

	count := int64(len(s))
	if start >= count {
		return nil
	}
	if end == 0 || end > count {
		end = count
	}

	return s[start:end]
}
Code Lisa
关注
  • 11
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Go实战--go中一些有用的代码片段(The way to go)
一蓑烟雨任平生 也无风雨也无晴
06-14 6019
生命不止，继续 go go go !!!今天跟大家分享一些有用的，简单的golang代码片段。改变string的值 首先我们要知道，在golang中，string是不可变的： str := "hello" str[0] = 'c'编译错误：cannot assign to str[0]正确的做法：package mainimport ( "fmt" )func main()
go片段代码
weixin_30567225的博客
03-28 86
关于枚举类型 转载于:https://www.cnblogs.com/yewook/p/10615433.html
Golang代码片段
轱辘科技
05-24 232
Golang遍历字符串 package main import "fmt" func main() { aString := "Kanye West" for k,v := range aString{ fmt.Println(k, string(v)) } for k,v := range aString{ fmt.Printf("%v:%q\n",k, v) } } 0 K 1 a 2 n 3 y 4 e 5 6 W 7 e 8 s 9 t 0:'K' 1:'a'
go vscode 代码片段快速生成
qq_42217263的博客
05-23 252
pkgm：生成main包+main主函数。fp：Println换行输出。tys：快捷构建结构体。
VScode Go语言代码片段快速生成汇总
相守之路
07-04 2372
Go语言代码片段快速生成汇总基本pkgmHTTP开发hfherrhandhelloweb 本文结构： 不同使用习惯或开发模块通过父标题分类。 子标题对应一个VScode Go代码提示关键词，内容为具体生成的代码片段。 使用前置知识： 生成的代码会默认光标 有多个光标时，自定义完当前光标内容后，按tab会自动跳转到下一个光标 分享VScode的使用，掌握这些帮助你提高开发效率，不定期更新… 自定义代码段教程 基本 pkgm package main func main() { } HTTP开发
Golang开发中常用的代码片段汇总
09-21
在Golang开发中，经常会遇到各种各样的场景，需要使用特定的代码片段来解决问题。以下是一些在实际工作中常用到的Golang代码示例： 1. **使用http包发送带有认证信息的请求**： 在Golang中，我们可以使用`http`包...
go-snippets:我多年来收集的随机Go代码片段
04-29
Go代码的随机摘要 我最初发布Go时是从这个存储库开始的。 然后六年来我什么都没放。 好吧，今晚我添加了一些内容，因此我也必须更新此文件。 我可能最终有时间（a）发布更多，并且（b）稍微整理一下古老的例子。 ...
go-code-snippet-library：golang的一些代码片段，轮子
02-13
【标题】"go-code-snippet-library" 是一个专门收集Golang代码片段的资源库，它包含了一系列用Go语言实现的常见功能或算法的简洁代码，旨在帮助开发者快速理解和复用这些"轮子"，提高开发效率。 【描述】这个库的...
pray:用于查找未使用的公共 Go 代码片段的工具
06-20
/Users/f/src/github.com/tsuru/config/checker.go:10:6: Check is unused /Users/f/src/github.com/tsuru/config/config.go:113:6: WriteConfigFile is unused /Users/f/src/github....
Go 语言返回组装数据
qq_51110402的博客
07-14 100
【代码】Go 语言返回组装数据。
使用Go编写的持续下行测速脚本，快速消耗流量且不伤硬盘
坐公交也用券
07-10 508
使用go语言编写的持续下行测速脚本,可用于任意平台使用,通过指定URL清单文本文件自动遍历测速,支持多线程,支持多平台。
Go语言指针及不支持语法汇总
最新发布
json_li的博客
07-14 116
本文为Go语言中指针定义和示例及不支持语法汇总。
【Go系列】 Sync并发控制
u013379032的博客
07-14 619
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
golang程序性能提升改进篇之文件的读写---第一篇
russle的专栏
07-14 184
这个程序是计算和io密集型，调用流量属于明显有波峰波谷，但是因为各种原因，当前无法快速通过serverless或者动态在高峰时段调整资源，低峰释放资源的方式进行解决，因此只能通过分析内存和cpu消耗热点，然后改动代码，进而解决服务的稳定性和性能问题。通过搜索了解golang程序如何进行性能分析，当时就是使用pprof了，通过分析发现了程序有一些使用内存较多的地方，例如我们读取大量文件，通过分析发现io.ioutil.ReadAll消耗内存较多，通过查询发现io.copy可以减少一些内存消耗。
Golang | Leetcode Golang题解之第233题数字1的个数
weixin_66442839的博客
07-14 179
Golang | Leetcode Golang题解之第233题数字1的个数
Golang 高频面试题 && 答案
Lushengshi的博客
07-10 854
在探讨Go语言的并发安全性时，让我们首先理解其核心概念：并发安全性意味着即使在多任务并行执行的环境下，程序也能保持其逻辑的正确性和数据的一致性，避免诸如数据竞争、死锁或活锁等并发问题的出现。通道是并发安全的数据结构。通过这些方法，Go语言的开发者可以构建出既高效又安全的并发程序，确保在多任务环境中程序的稳定性和可靠性。例如，要移除切片中的第三个元素，可以使用切片的切片操作将切片分为两部分，并将第三个元素从中间移除。数组的元素类型和长度是数组类型的一部分，因此不同长度或不同元素类型的数组是不同的类型。
Github 2024-07-11 Go开源项目日报 Top10
老孙正经胡说
07-11 674
根据Github Trendings的统计，今日(2024-07-11统计)共有10个项目上榜。
Gocator Acquisition for Cognex VisionPro（LMI相机图像获取）
视觉人机器视觉的博客
07-13 74
Gocator Acquisition for Cognex VisionPro（LMI相机图像获取）
【Go系列】 Struct与interface
u013379032的博客
07-12 734
structAge intimport ("fmt""math"c.Scale(2)在上面的例子中，Area方法是一个值接收者方法，它返回圆的面积。Scale方法是一个指针接收者方法，它修改圆的半径。interfaceGo语言的设计哲学与传统的面向对象语言不同，它不提供传统的继承机制，而是使用组合（embedding）和接口来实现代码复用和多态。
go语言小游戏代码130行左右
06-19
对不起，由于我无法查看具体的代码片段或文件内容，我无法直接提供130行左右的Go语言小游戏代码。不过，我可以给你一些基本的指导，如果你正在编写一个Go语言游戏，130行左右可能包含了游戏循环、输入处理、游戏对象...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值