Go并发模式/设计模式之心跳

最新推荐文章于 2023-03-12 15:40:46 发布
最新推荐文章于 2023-03-12 15:40:46 发布
阅读量618 收藏 2
点赞数
分类专栏： go语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013862108/article/details/89716801
版权 
心跳是 并发进程向外界发出信号的一种方式

两种不同类型的心跳：
1。 在一段时间间隔内发出的心跳
2。 在工作单元开始时发出的心跳。
func main() {
	doWork := func(done <-chan interface{}, pulseInterval time.Duration) (<-chan interface{}, <-chan time.Time) {
		heartbeat := make(chan interface{})
		results := make(chan time.Time)
		go func() {
			defer close(heartbeat)
			defer close(results)

			//pulseInterval 是心跳间隔。
			pulse := time.Tick(pulseInterval)
			workGen := time.Tick(2*pulseInterval)   //模拟滴答声的channel.

			sendPulse := func() {
				select{
				case heartbeat <- struct {}{}:
				default:     //注意！！ 可能没有人接收我们的心跳。

				}
			}

			sendResult := func(r time.Time) {
				for {
					select{
					case <- done:
						return
					case <- pulse:
						sendPulse()
					case results <- r:
						return
					}
				}
			}

			for{
				select{
				case <-done:
					return
				case <-pulse:
					sendPulse()
				case r := <-workGen:
					sendResult(r)
				}
			}

		}()

		return heartbeat, results
	}


	done := make(chan interface{})

	//设置了超时时间，10s后 关闭。
	time.AfterFunc(10*time.Second, func(){ close(done)})


	const timeout = 2*time.Second
	heartbeat, results := doWork(done, timeout/2)

	for{
		select{
		case _, ok := <-heartbeat:
			if ok == false{
				return
			}
			fmt.Println("pulse")
		case r, ok := <-results:
			if ok == false{
				return
			}
			fmt.Printf("results %v\n", r.Second())
		case <-time.After(timeout):
			return
		}
	}
}


//pulse
//pulse
//results 19
//pulse
//pulse
//results 21
//pulse
//pulse
//results 23
//pulse
//pulse
//results 25
//pulse
//pulse
//模拟异常的 goroutine
两次迭代后停止goroutine, 但却不关闭 heartbeat, results 这两个channel; 来模拟产生异常的goroutine
func doWork2 (done <-chan interface{}, pulseInterval time.Duration)(<-chan interface{}, <-chan time.Time){
	heartbeat := make(chan interface{})
	results := make(chan time.Time)
	go func() {
		pulse := time.Tick(pulseInterval)
		//workGen :=time.Tick(2*pulseInterval)
		workGen :=time.Tick(1*pulseInterval)

		sendPulse := func() {
			select{
			case  heartbeat <- struct{}{}:
			default:
			}
		}

		sendResult := func(r time.Time) {
			for{
				select{
				case <-pulse:
					sendPulse()
				case results <- r:
					return
				}
			}
		}

		for i:=0; i<2; i++{
			select{
			case <-done:
				return
			case <-pulse:
				sendPulse()
			case r := <-workGen:
				sendResult(r)
			}
		}
	}()

	return heartbeat, results
}


func main(){
	done := make(chan interface{})
	time.AfterFunc(10*time.Second, func(){close(done)})

	const timeout = 10*time.Second   //2 s
	heartbeat, results := doWork2(done, timeout/2)

	for{
		select{
		case _,ok := <-heartbeat:
			if ok == false{
				return
			}
			fmt.Println("pulse")
		case r, ok := <- results:
			if ok == false{
				return
			}
			fmt.Printf("results %v\n", r)
		case <- time.After(timeout):
			fmt.Println("worker goroutine is not healthy!")
			return
		}
	}

}

//pulse
//pulse
//worker goroutine is not healthy!

//pulse
//results 2019-04-28 23:39:32.402908 +0800 CST m=+5.001073022
//worker goroutine is not healthy!
/**

在工作单元开始时发出心跳的例子：这种写法真正的好处是 在于测试
func doWork3(done <- chan interface{})(<-chan interface{}, <- chan int){
	heartbeatStream := make(chan interface{}, 1)
	workStream := make(chan int)

	go func(){
		defer close(heartbeatStream)
		defer close(workStream)

		for i:=0; i<10; i++{
			select{
			case heartbeatStream <- struct {}{}:
			default:
			}
			select{
			case <- done:
				return
			case workStream <- rand.Intn(10) :
			}
		}

	}()

	return heartbeatStream, workStream
}


func main(){
	done := make(chan interface{})
	defer close(done)

	heartbeat, results := doWork3(done)
	for{
		select{
		case _, ok := <- heartbeat:
			if ok{
				fmt.Println("pulse")
			} else {
				return
			}
		case r, ok := <- results:
			if ok {
				fmt.Printf("results %v\n", r)
			} else {
				return
			}
		}
	}
}

//pulse
//results 1
//pulse
//results 7
//pulse
//results 7
//pulse
//results 9
//pulse
//results 1
//pulse
//results 8
//pulse
//results 5
//pulse
//results 0
//pulse
//results 6
//pulse
//results 0


不好的 为了能测试的 写法
func DoWork4(done <-chan interface{}, nums ...int)(<-chan interface{}, <-chan int){
	heartbeat := make(chan interface{}, 1)
	intStream := make(chan int)

	go func(){
		defer close(heartbeat)
		defer close(intStream)

		//模拟在goroutine 开始工作之前的某种延迟。 在实践中可能是各种各样问题。可能是cpu 负载过高，磁盘抢占，
		//网络延迟 造成的延迟。
		time.Sleep(2*time.Second)


		for _,n := range nums{
			select{
			case heartbeat <- struct{}{}:
			default:
			}

			select{
			case <- done:
				return
			case intStream <- n:
			}

		}


	}()

	return heartbeat, intStream
}

func TestDoWork4_GeneratesAllNumbers(t *testing.T) {
	done := make(chan interface{})
	defer close(done)

	intSlice := []int{0,1,2,3,5}
	_, results := DoWork4(done, intSlice...)

	for i, expected := range intSlice{
		select{
		case r:= <- results:
			if r != expected{
				t.Errorf(
					"index %v: expected %v, but received %v,",
					i,
					expected,
					r,
					)
			}

			//这里设置一个合理的超时时间，避免goroutine 陷入 死锁
		case <-time.After(1*time.Second)	:
			t.Fatal("test timed out")
		}
	}
}

//=== RUN   TestDoWork4_GeneratesAllNumbers
//--- FAIL: TestDoWork4_GeneratesAllNumbers (1.00s)
//heart_test.go:29: test timed out
//FAIL

/**
这个测试不够好，因为它是非确定性的。 再者，增加超时时间，这意味着需要很长时间才知道执行失败，从而减慢我们的测试过程

然而利用心跳可以 很容易解决这个问题。这是一个确定性的测试：
func TestDoWork4(t *testing.T) {
	done := make(chan interface{})
	defer close(done)

	intSlice := []int{0,1,2,3,4,5}
	heartbeat, reuslts := DoWork4(done, intSlice...)

	<- heartbeat

	i:=0
	for r := range reuslts{
		if expected := intSlice[i]; r!= expected{
			t.Errorf("index %v: expected %v, but received %v,", i, expected, r)
		}
		i++
	}

}
/**
分析：因为有了心跳，就可以安全的编写测试 而不需要加入超时机制。
更完美的间隔心跳 ：Dowork5
func DoWork5(done <-chan interface{}, pulseInterval time.Duration, nums ...int)(<-chan interface{}, <-chan int){
	heartbeat := make(chan interface{}, 1)
	intStream := make(chan int)

	go func() {
		defer close(heartbeat)
		defer close(intStream)

		time.Sleep(2*time.Second)

		pulse := time.Tick(pulseInterval)
		numLoop:

			for _, n := range nums{
				for {
					select{
					case <- done:
						return
					case <-pulse:
						select{
						case heartbeat <- struct {}{}:
							fmt.Println("sendHeart")
						default:
						}
						//fmt.Println("jump")
					//case intStream <- n:
					case intStream <- realWork(n):
						//fmt.Println("work")
						//time.Sleep(3*time.Second)
						continue numLoop
					}
				}
			}

	}()

	return heartbeat, intStream
}

func realWork(n int) int{
	fmt.Println("n : ", n)
	fmt.Println("work start")
	time.Sleep(3*time.Second)
	fmt.Println("work end")
	return 2*n
}


func main(){
	done := make(chan interface{})
	defer close(done)

	intSlice := []int{0,1,2,3,5}
	const timeout = 2*time.Second
	heartbeat, results := DoWork5(done, timeout/2, intSlice...)
	for{
		select{
		case _, ok := <- heartbeat:
			if ok{
				fmt.Println("pulse")
			} else {
				return
			}
		case r, ok := <- results:
			if ok {
				fmt.Printf("results %v\n", r)
			} else {
				return
			}
		}
	}
}


//n :  0
//work start
//work end
//sendHeart
//n :  0
//work start
//pulse
//work end
//sendHeart
//n :  0
//work start
//pulse
//work end
//sendHeart
//pulse
//n :  0
//work start
//work end
//sendHeart
//n :  0
//work start
//pulse
//work end
//sendHeart
//n :  0
//work start
//pulse
//work end
//sendHeart
//n :  0
//work start
//pulse
//work end
//n :  1
//work start
//results 0
//work end
//sendHeart
//n :  1
//work start
//pulse
//work end
//n :  2
//work start
//results 2
//work end
//sendHeart
//n :  2
//work start
//pulse
//work end
//sendHeart
//n :  2
//work start
//pulse
//work end
//n :  3
//work start
//results 4
//work end
//n :  5
//work start
//results 6
//work end
//sendHeart
//n :  5
//work start
//pulse
//work end
//sendHeart
//n :  5
//work start
//pulse
//work end
//results 10

/**
分析 为什么 n 会重复多次 ，难道 <- n  ; n不适合 用函数？  n多次 是因为 没有成功将 返回值 放入channel ?


 */
func TestDoWork5(t *testing.T) {
	done := make(chan interface{})
	defer close(done)

	intSlice := []int{0,1,2,3,5}
	const timeout = 2*time.Second
	heartbeat, results := DoWork5(done, timeout/2, intSlice...)

	//等待第一次心跳到底，来确认goroutine 已经进入了循环
	<-heartbeat
	fmt.Println("get first heart")

	//r, ok:= <- results
	//if ok {
	//	fmt.Printf("get result %v ", r)
	//}

	i:=0
	for{
		fmt.Println("get start for")
		select{
		case r, ok:= <- results:
			fmt.Println("work result")
			//time.Sleep(3*time.Second);
			if ok == false{
				return
			} else if expected := intSlice[i]; r!= expected{
				t.Errorf(
					"index %v: expected %v, but received %v,",
					i,
					expected,
					r,
					)
			}
			i++

		//接收心跳防止 超时
		case <- heartbeat:
			fmt.Println("pulse")
		case <- time.After(timeout):
			t.Fatal("test timed out")
		}
	}

}

//=== RUN   TestDoWork5
//work start
//work end
//sendHeart
//work start
//get first heart
//get start for
//--- FAIL: TestDoWork5 (7.01s)
//heart_test.go:113: test timed out
//FAIL

 

学海无涯书山有路
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Golang 心跳的实现
冷月醉雪的博客
02-02 1万+
    在多客户端同时访问服务器的工作模式下，首先要保证服务器的运行正常。因此，Server和Client建立通讯后，确保连接的及时断开就非常重要。否则，多个客户端长时间占用着连接不关闭，是非常可怕的服务器资源浪费。会使得服务器可服务的客户端数量大幅度减少。    因此，针对短链接和长连接，根据业务的需求，配套不同的处理机制。 短连接     一般建立完连接，就立刻传输数据。传输完数据，连接...
Golang心跳机制实现示例
程序创坊
09-11 3537
前言: 最近在做一款产品，服务端需要监测客户端状态(在线/离线)。服务端报表展示客户端的上下线次数和运行时长等信息。 通用的处理方式: 客户端发送心跳请求+重试机制。重试X次失败则定义为离线 服务端响应心跳请求+超时机制。超时X秒未收到心跳请求则定义为下线 //服务端​ //全局变量 var ids = make(map[string]chan byte) ​...
Go语言并发之道学习九 心跳
daily886的博客
08-26 323
并发进程检测-心跳 package main import ( "math/rand" "time" "fmt" ) /* 并发进程取消的原因： ·超时：超时是隐式取消 ·用户干预：为了获取良好的用户体验，通常建议维持一个长连接，然后以轮询间隔将状态报告发送给用户，或允许用户查看他们认为合适的状态。 当用户使用并发程序时，有时需要允许用户取消他们已经开始的操作。 ·父进程取消：对...
golang tcp server client
翔云
10-05 4837
实例代码如下：serverimport ( &quot;fmt&quot; &quot;net&quot; &quot;log&quot; )func main() { addr := &quot;0.0.0.0:8080&quot; tcpAddr, err := net.ResolveTCPAddr(&quot;tcp&quot;,addr)
Golang心跳包
weixin_38104426的博客
09-17 2673
server端    package main import ( "net" "fmt" "os" "time" ) func main() { server := ":7373" netListen, err := net.Listen("tcp", server) if err != nil{ LogC("connect error: &quot
Go的容错和弹性模式.zip
最新发布
05-25
在分布式系统设计中，容错和弹性是两个关键概念，特别是在使用Go语言开发高可用服务时尤为重要。Go语言以其并发模型、高效的性能以及简洁的语法，成为构建大规模、高并发应用的理想选择。在这个名为"Go的容错和弹性...
非C/S模式p2p聊天程序
07-13
多线程、异步I/O或者使用如Golang的goroutine和通道等并发模型可以实现这一目标。 7. **错误恢复与容错**：P2P网络中节点可能随时加入或离开，因此需要有错误检测和恢复机制，例如心跳机制来检测节点的在线状态，...
Go-Golet以使用goroutine从一个golang程序管理许多服务
08-14
Golet是一种设计模式，它利用了Golang编程语言中的核心特性——goroutines，来实现从一个单一的Golang程序高效地管理和控制多个并发执行的服务。这个模式尤其适用于构建微服务架构或者需要处理大量并发请求的应用。 ...
Go 基于 Raft 共识算法的分布式可靠的 KV 存储系统源码.zip
12-14
2. **Go语言特性**：Go语言的并发模型基于goroutines和channels，使得构建高并发的分布式系统变得简单。在gokvs中，每个节点可能有多个goroutine分别处理网络通信、日志复制和状态机更新等任务。 3. **键值对存储**...
Go-MaChat是Go实现的一个开源聊天服务器
08-13
Go语言（又称Golang）是由Google开发的一种静态类型、编译型、并发型且具有垃圾回收功能的编程语言。它的设计目标是提高开发者的生产力，同时保持系统的可扩展性和高效率。Go语言中的`net`包提供了丰富的网络编程...
pr0t0:Workend平台的原型工具
05-12
pr0t0 Workend平台的原型工具
golang实现带有心跳检测的tcp长连接
chuojianpeng9484的博客
06-23 6581
package main // golang实现带有心跳检测的tcp长连接 // server import ( "fmt" "net" "time" ) // message struct: // c#d var ( Req_REGISTER byte = 1 // 1 ---...
Golang 长连接的时候是怎样做心跳机制的
enjoy_sun_moon的博客
06-05 1409
客户端发送心跳请求+重试机制。重试X次失败则定义为离线 服务端响应心跳请求+超时机制。超时X秒未收到心跳请求则定义为下线 //服务端​ //全局变量 var ids = make(map[string]chan byte) ​ func ResponseHeartBeat(id string) { if _, ok := ids[id]; ok { //保活心跳请求 ids[id] <- 0 } else { //上线触发器 ...
Golang 实现http协议的心跳检测程序
neweastsun的专栏
03-12 1794
本文介绍如何使用Golang实现心跳程序。实现心跳程序，其他应用可以简单集成。客户端程序通过HTTP协议进行检测，返回当前程序状态、版本ID以及已运行时间。
Go并发设计
学无止境
10-01 222
goroutine(极少的栈内存，比thread更易用、更高效、更轻便) runtime.Gosched()表示把CPU时间片让给别人，下次某个时候恢复执行该goroutine 想要发挥多核处理器的并行，设置runtime.GOMAXPROCS(n) 默认情况下，channel接受和发送数据都是阻塞的，除非另一端已经准备好，这样就使得goroutines同步变的更加的
Golang 并发编程总结
冷月醉雪的博客
03-29 3031
   Golang :不要通过共享内存来通信，而应该通过通信来共享内存。这句风靡在Go社区的话,说的就是 goroutine中的 channel …….      他在go并发编程中充当着 类型安全的管道作用。   1.通过golang中的 goroutine 与sync.Mutex进行 并发同步 import(    "fmt"    "sync"    "runtime" ...
BroadcastReceiver中的那些设计模式
IZZY
05-25 5216
前文写过BroadCastReceiver的源码的分析BroadcastReceiver源码解析（二），文章很长终于把广播的注册和发送流程详细的分析了一遍。最近用RationalRose画了画它的类图，于是将BroadCastReceiver中涉及的设计模式分析分析，准备再扒一层。 由于技术水平有限，研究了BroadCastReceiver的过程中，目前只发现涉及到了三种设计模式，分别为观察者，代
Go语言常用的并发模式（上）
Erick Lv的笔记
08-29 1894
Confinement 该模式用于处理数据限制问题，类似于生产者和消费者模式。使用channel的方式通过共享信息的方式进行。有一个协程专门负责生产，另外一个协程负责接收数据。代码中使用随机的时间模拟实际情况中耗时部分。 package main import ( &amp;amp;quot;fmt&amp;amp;quot; &amp;amp;quot;math/rand&amp;amp;quot; &amp;amp;quot;time
Go并发模式之pipeline(管道)
u013862108的博客
04-06 2603
pipeline pipeline 是你可以用来在系统中形成抽象的另一种工具。特别是当程序需要流式处理 或批处理数据时，它是一个非常强大的工具。 pipeline 只不过是一系列将数据输入， 执行操作并将结果数据传回的系统。 将这些操作称为 pipeline 的一个 stage. 通过使用pipeline, 可以分离每个stage的关注点， 这提供了很多好处。如可以可以相互独立地修改各个...
L14-设计模式-行为型模式v21
08-04
案例与设计模式 I黄民烈课程团队：刘知远 姚海龙 黄民烈上期要点回顾并发编程mutex与互斥锁模式async、future、promise与异步设计模式简介设计

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值