Golang框架实战-KisFlow流式计算框架(10)-Flow多副本

最新推荐文章于 2024-04-04 09:55:52 发布
最新推荐文章于 2024-04-04 09:55:52 发布
阅读量479 收藏 11
点赞数 9
文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40239222/article/details/137034971
版权

Golang框架实战-KisFlow流式计算框架专栏

Golang框架实战-KisFlow流式计算框架(1)-概述
Golang框架实战-KisFlow流式计算框架(2)-项目构建/基础模块-(上)
Golang框架实战-KisFlow流式计算框架(3)-项目构建/基础模块-(下)
Golang框架实战-KisFlow流式计算框架(4)-数据流
Golang框架实战-KisFlow流式计算框架(5)-Function调度
Golang框架实战-KisFlow流式计算框架(6)-Connector
Golang框架实战-KisFlow流式计算框架(7)-配置导入与导出
Golang框架实战-KisFlow流式计算框架(8)-KisFlow Action
Golang框架实战-KisFlow流式计算框架(9)-Cache/Params 数据缓存与数据参数
Golang框架实战-KisFlow流式计算框架(10)-Flow多副本

9.1 多副本能力

KisFlow如果在执行流体中，需要被多个Goroutine来并发使用，可能需要同一个配置的创建多个Flow来匹配多个并发的计算流，所以Flow需要一个创建副本的能力。本章将实现这部分的能力。

9.1.1 Flow新增接口

首先，给Flow的抽象层新增一个接口Fork()，原型如下：

kis-flow/kis/flow.go

type Flow interface {
	// Run 调度Flow，依次调度Flow中的Function并且执行
	Run(ctx context.Context) error
	// Link 将Flow中的Function按照配置文件中的配置进行连接
	Link(fConf *config.KisFuncConfig, fParams config.FParam) error
	// CommitRow 提交Flow数据到即将执行的Function层
	CommitRow(row interface{}) error
	// Input 得到flow当前执行Function的输入源数据
	Input() common.KisRowArr
	// GetName 得到Flow的名称
	GetName() string
	// GetThisFunction 得到当前正在执行的Function
	GetThisFunction() Function
	// GetThisFuncConf 得到当前正在执行的Function的配置
	GetThisFuncConf() *config.KisFuncConfig
	// GetConnector 得到当前正在执行的Function的Connector
	GetConnector() (Connector, error)
	// GetConnConf 得到当前正在执行的Function的Connector的配置
	GetConnConf() (*config.KisConnConfig, error)
	// GetConfig 得到当前Flow的配置
	GetConfig() *config.KisFlowConfig
	// GetFuncConfigByName 得到当前Flow的配置
	GetFuncConfigByName(funcName string) *config.KisFuncConfig
	// Next 当前Flow执行到的Function进入下一层Function所携带的Action动作
	Next(acts ...ActionFunc) error
	// GetCacheData 得到当前Flow的缓存数据
	GetCacheData(key string) interface{}
	// SetCacheData 设置当前Flow的缓存数据
	SetCacheData(key string, value interface{}, Exp time.Duration)
	// GetMetaData 得到当前Flow的临时数据
	GetMetaData(key string) interface{}
	// SetMetaData 设置当前Flow的临时数据
	SetMetaData(key string, value interface{})
	// GetFuncParam 得到Flow的当前正在执行的Function的配置默认参数，取出一对key-value
	GetFuncParam(key string) string
	// GetFuncParamAll 得到Flow的当前正在执行的Function的配置默认参数，取出全部Key-Value
	GetFuncParamAll() config.FParam


    // +++++++++++++++++++++++++
	// Fork 得到Flow的一个副本(深拷贝)
	Fork(ctx context.Context) Flow
}

Fork()会根据一个已有的KisFlow实例，完全克隆一个资源隔离的但是具有相同配置的KisFlow实例。
具体的实现方法如下：

kis-flow/flow/kis_flow.go

// Fork 得到Flow的一个副本(深拷贝)
func (flow *KisFlow) Fork(ctx context.Context) kis.Flow {

	config := flow.Conf

	// 通过之前的配置生成一个新的Flow
	newFlow := NewKisFlow(config)

	for _, fp := range flow.Conf.Flows {
		if _, ok := flow.funcParams[flow.Funcs[fp.FuncName].GetId()]; !ok {
			//当前function没有配置Params
			newFlow.Link(flow.Funcs[fp.FuncName].GetConfig(), nil)
		} else {
			//当前function有配置Params
			newFlow.Link(flow.Funcs[fp.FuncName].GetConfig(), fp.Params)
		}
	}

	log.Logger().DebugFX(ctx, "=====>Flow Fork, oldFlow.funcParams = %+v\n", flow.funcParams)
	log.Logger().DebugFX(ctx, "=====>Flow Fork, newFlow.funcParams = %+v\n", newFlow.GetFuncParamsAllFuncs())

	return newFlow
}

在Fork()中，首先会根据flow的配置信息，重新创建一个KisFlow实例，并且将flow所关联的Params等配置信息一同拷贝，最后通过Link()将新建的Function和Flow连接起来。

上述代码为了调试，给Flow新增了一个打印全部FuncParams信息的接口GetFuncParamsAllFuncs()，具体的实现方式如下：

kis-flow/kis/flow.go

type Flow interface {
	// ... ...
    // ... ...
    
	// GetFuncParamsAllFuncs 得到Flow中所有Function的FuncParams，取出全部Key-Value
	GetFuncParamsAllFuncs() map[string]config.FParam

    // ... ...
}

kis-flow/flow/kis_flow_data.go

// GetFuncParamsAllFuncs 得到Flow中所有Function的FuncParams，取出全部Key-Value
func (flow *KisFlow) GetFuncParamsAllFuncs() map[string]config.FParam {
	flow.fplock.RLock()
	defer flow.fplock.RUnlock()

	return flow.funcParams
}

9.2 单元测试

下面我们来测试一个Fork能力，单元测试代码如下：

kis-flow/test/kis_fork_test.go

func TestForkFlow(t *testing.T) {
	ctx := context.Background()

	// 0. 注册Function 回调业务
	kis.Pool().FaaS("funcName1", faas.FuncDemo1Handler)
	kis.Pool().FaaS("funcName2", faas.FuncDemo2Handler)
	kis.Pool().FaaS("funcName3", faas.FuncDemo3Handler)

	// 0. 注册ConnectorInit 和 Connector 回调业务
	kis.Pool().CaaSInit("ConnName1", caas.InitConnDemo1)
	kis.Pool().CaaS("ConnName1", "funcName2", common.S, caas.CaasDemoHanler1)

	// 1. 加载配置文件并构建Flow
	if err := file.ConfigImportYaml("/Users/tal/gopath/src/kis-flow/test/load_conf/"); err != nil {
		panic(err)
	}

	// 2. 获取Flow
	flow1 := kis.Pool().GetFlow("flowName1")

	flow1Clone1 := flow1.Fork(ctx)

	// 3. 提交原始数据
	_ = flow1Clone1.CommitRow("This is Data1 from Test")
	_ = flow1Clone1.CommitRow("This is Data2 from Test")
	_ = flow1Clone1.CommitRow("This is Data3 from Test")

	// 4. 执行flow1
	if err := flow1Clone1.Run(ctx); err != nil {
		panic(err)
	}
}

首先我们先创建flowName1的flow实例，然后通过fork()得到flowClone1，然后执行flowClone1的调度流程。

cd到kis-flow/test/下执行：

go test -test.v -test.paniconexit0 -test.run TestForkFlow

结果如下：

=== RUN   TestForkFlow
Add KisPool FuncName=funcName1
Add KisPool FuncName=funcName2
Add KisPool FuncName=funcName3
Add KisPool CaaSInit CName=ConnName1
Add KisPool CaaS CName=ConnName1, FName=funcName2, Mode =Save
===> Call Connector InitDemo1
&{conn ConnName1 0.0.0.0:9988,0.0.0.0:9999,0.0.0.0:9990 redis redis-key map[args1:value1 args2:value2] [] [funcName2 funcName2]}
Add FlowRouter FlowName=flowName1
Add FlowRouter FlowName=flowName2
Add FlowRouter FlowName=flowName3
Add FlowRouter FlowName=flowName4
===> Call Connector InitDemo1
&{conn ConnName1 0.0.0.0:9988,0.0.0.0:9999,0.0.0.0:9990 redis redis-key map[args1:value1 args2:value2] [] [funcName2 funcName2 funcName2]}
Add FlowRouter FlowName=flowName5
===> Call Connector InitDemo1
&{conn ConnName1 0.0.0.0:9988,0.0.0.0:9999,0.0.0.0:9990 redis redis-key map[args1:value1 args2:value2] [] [funcName2 funcName2 funcName2]}
context.Background
=====>Flow Fork, oldFlow.funcParams = map[func-6b00f430fe494302a384c2ae09eb019c:map[default1:funcName3_param1 default2:funcName3_param2 myKey1:flowValue3-1 myKey2:flowValue3-2] func-bf9df5fc16684200b78f32985d073012:map[default1:funcName2_param1 default2:funcName2_param2 myKey1:flowValue2-1 myKey2:flowValue2-2] func-c0f1ae9850174f81b994a2e98fb34109:map[default1:funcName1_param1 default2:funcName1_param2 myKey1:flowValue1-1 myKey2:flowValue1-2]]

context.Background
=====>Flow Fork, newFlow.funcParams = map[func-614511f5142e4023b80373517f3ea0a7:map[default1:funcName3_param1 default2:funcName3_param2 myKey1:flowValue3-1 myKey2:flowValue3-2] func-9406285e2fa94bd582dab4a875771a97:map[default1:funcName1_param1 default2:funcName1_param2 myKey1:flowValue1-1 myKey2:flowValue1-2] func-de7c4e4175b74a898cb43863e53b3215:map[default1:funcName2_param1 default2:funcName2_param2 myKey1:flowValue2-1 myKey2:flowValue2-2]]

context.Background
====> After CommitSrcData, flow_name = flowName1, flow_id = flow-38c362e52fee489db3af96ae7d83d56a
All Level Data =
 map[FunctionIdFirstVirtual:[This is Data1 from Test This is Data2 from Test This is Data3 from Test]]

KisFunctionV, flow = &{Id:flow-38c362e52fee489db3af96ae7d83d56a Name:flowName1 Conf:0xc000153f80 Funcs:map[funcName1:0xc00014d180 funcName2:0xc00014d200 funcName3:0xc00014d300] FlowHead:0xc00014d180 FlowTail:0xc00014d300 flock:{w:{state:0 sema:0} writerSem:0 readerSem:0 readerCount:0 readerWait:0} ThisFunction:0xc00014d180 ThisFunctionId:func-9406285e2fa94bd582dab4a875771a97 PrevFunctionId:FunctionIdFirstVirtual funcParams:map[func-614511f5142e4023b80373517f3ea0a7:map[default1:funcName3_param1 default2:funcName3_param2 myKey1:flowValue3-1 myKey2:flowValue3-2] func-9406285e2fa94bd582dab4a875771a97:map[default1:funcName1_param1 default2:funcName1_param2 myKey1:flowValue1-1 myKey2:flowValue1-2] func-de7c4e4175b74a898cb43863e53b3215:map[default1:funcName2_param1 default2:funcName2_param2 myKey1:flowValue2-1 myKey2:flowValue2-2]] fplock:{w:{state:0 sema:0} writerSem:0 readerSem:0 readerCount:0 readerWait:0} buffer:[] data:map[FunctionIdFirstVirtual:[This is Data1 from Test This is Data2 from Test This is Data3 from Test]] inPut:[This is Data1 from Test This is Data2 from Test This is Data3 from Test] abort:false action:{DataReuse:false ForceEntryNext:false JumpFunc: Abort:false} cache:0xc00011aae0 metaData:map[] mLock:{w:{state:0 sema:0} writerSem:0 readerSem:0 readerCount:0 readerWait:0}}

---> Call funcName1Handler ----
Params = map[default1:funcName1_param1 default2:funcName1_param2 myKey1:flowValue1-1 myKey2:flowValue1-2]
In FuncName = funcName1, FuncId = func-9406285e2fa94bd582dab4a875771a97, row = This is Data1 from Test
In FuncName = funcName1, FuncId = func-9406285e2fa94bd582dab4a875771a97, row = This is Data2 from Test
In FuncName = funcName1, FuncId = func-9406285e2fa94bd582dab4a875771a97, row = This is Data3 from Test
context.Background
 ====> After commitCurData, flow_name = flowName1, flow_id = flow-38c362e52fee489db3af96ae7d83d56a
All Level Data =
 map[FunctionIdFirstVirtual:[This is Data1 from Test This is Data2 from Test This is Data3 from Test] func-9406285e2fa94bd582dab4a875771a97:[data from funcName[funcName1], index = 0 data from funcName[funcName1], index = 1 data from funcName[funcName1], index = 2]]

KisFunctionS, flow = &{Id:flow-38c362e52fee489db3af96ae7d83d56a Name:flowName1 Conf:0xc000153f80 Funcs:map[funcName1:0xc00014d180 funcName2:0xc00014d200 funcName3:0xc00014d300] FlowHead:0xc00014d180 FlowTail:0xc00014d300 flock:{w:{state:0 sema:0} writerSem:0 readerSem:0 readerCount:0 readerWait:0} ThisFunction:0xc00014d200 ThisFunctionId:func-de7c4e4175b74a898cb43863e53b3215 PrevFunctionId:func-9406285e2fa94bd582dab4a875771a97 funcParams:map[func-614511f5142e4023b80373517f3ea0a7:map[default1:funcName3_param1 default2:funcName3_param2 myKey1:flowValue3-1 myKey2:flowValue3-2] func-9406285e2fa94bd582dab4a875771a97:map[default1:funcName1_param1 default2:funcName1_param2 myKey1:flowValue1-1 myKey2:flowValue1-2] func-de7c4e4175b74a898cb43863e53b3215:map[default1:funcName2_param1 default2:funcName2_param2 myKey1:flowValue2-1 myKey2:flowValue2-2]] fplock:{w:{state:0 sema:0} writerSem:0 readerSem:0 readerCount:0 readerWait:0} buffer:[] data:map[FunctionIdFirstVirtual:[This is Data1 from Test This is Data2 from Test This is Data3 from Test] func-9406285e2fa94bd582dab4a875771a97:[data from funcName[funcName1], index = 0 data from funcName[funcName1], index = 1 data from funcName[funcName1], index = 2]] inPut:[data from funcName[funcName1], index = 0 data from funcName[funcName1], index = 1 data from funcName[funcName1], index = 2] abort:false action:{DataReuse:false ForceEntryNext:false JumpFunc: Abort:false} cache:0xc00011aae0 metaData:map[] mLock:{w:{state:0 sema:0} writerSem:0 readerSem:0 readerCount:0 readerWait:0}}

---> Call funcName2Handler ----
Params = map[default1:funcName2_param1 default2:funcName2_param2 myKey1:flowValue2-1 myKey2:flowValue2-2]
In FuncName = funcName2, FuncId = func-de7c4e4175b74a898cb43863e53b3215, row = data from funcName[funcName1], index = 0
===> In CaasDemoHanler1: flowName: flowName1, cName:ConnName1, fnName:funcName2, mode:Save
Params = map[args1:value1 args2:value2]
===> Call Connector CaasDemoHanler1, args from funciton: data from funcName[funcName1], index = 0
In FuncName = funcName2, FuncId = func-de7c4e4175b74a898cb43863e53b3215, row = data from funcName[funcName1], index = 1
===> In CaasDemoHanler1: flowName: flowName1, cName:ConnName1, fnName:funcName2, mode:Save
Params = map[args1:value1 args2:value2]
===> Call Connector CaasDemoHanler1, args from funciton: data from funcName[funcName1], index = 1
In FuncName = funcName2, FuncId = func-de7c4e4175b74a898cb43863e53b3215, row = data from funcName[funcName1], index = 2
===> In CaasDemoHanler1: flowName: flowName1, cName:ConnName1, fnName:funcName2, mode:Save
Params = map[args1:value1 args2:value2]
===> Call Connector CaasDemoHanler1, args from funciton: data from funcName[funcName1], index = 2
context.Background
 ====> After commitCurData, flow_name = flowName1, flow_id = flow-38c362e52fee489db3af96ae7d83d56a
All Level Data =
 map[FunctionIdFirstVirtual:[This is Data1 from Test This is Data2 from Test This is Data3 from Test] func-9406285e2fa94bd582dab4a875771a97:[data from funcName[funcName1], index = 0 data from funcName[funcName1], index = 1 data from funcName[funcName1], index = 2] func-de7c4e4175b74a898cb43863e53b3215:[data from funcName[funcName2], index = 0 data from funcName[funcName2], index = 1 data from funcName[funcName2], index = 2]]

KisFunctionC, flow = &{Id:flow-38c362e52fee489db3af96ae7d83d56a Name:flowName1 Conf:0xc000153f80 Funcs:map[funcName1:0xc00014d180 funcName2:0xc00014d200 funcName3:0xc00014d300] FlowHead:0xc00014d180 FlowTail:0xc00014d300 flock:{w:{state:0 sema:0} writerSem:0 readerSem:0 readerCount:0 readerWait:0} ThisFunction:0xc00014d300 ThisFunctionId:func-614511f5142e4023b80373517f3ea0a7 PrevFunctionId:func-de7c4e4175b74a898cb43863e53b3215 funcParams:map[func-614511f5142e4023b80373517f3ea0a7:map[default1:funcName3_param1 default2:funcName3_param2 myKey1:flowValue3-1 myKey2:flowValue3-2] func-9406285e2fa94bd582dab4a875771a97:map[default1:funcName1_param1 default2:funcName1_param2 myKey1:flowValue1-1 myKey2:flowValue1-2] func-de7c4e4175b74a898cb43863e53b3215:map[default1:funcName2_param1 default2:funcName2_param2 myKey1:flowValue2-1 myKey2:flowValue2-2]] fplock:{w:{state:0 sema:0} writerSem:0 readerSem:0 readerCount:0 readerWait:0} buffer:[] data:map[FunctionIdFirstVirtual:[This is Data1 from Test This is Data2 from Test This is Data3 from Test] func-9406285e2fa94bd582dab4a875771a97:[data from funcName[funcName1], index = 0 data from funcName[funcName1], index = 1 data from funcName[funcName1], index = 2] func-de7c4e4175b74a898cb43863e53b3215:[data from funcName[funcName2], index = 0 data from funcName[funcName2], index = 1 data from funcName[funcName2], index = 2]] inPut:[data from funcName[funcName2], index = 0 data from funcName[funcName2], index = 1 data from funcName[funcName2], index = 2] abort:false action:{DataReuse:false ForceEntryNext:false JumpFunc: Abort:false} cache:0xc00011aae0 metaData:map[] mLock:{w:{state:0 sema:0} writerSem:0 readerSem:0 readerCount:0 readerWait:0}}

---> Call funcName3Handler ----
Params = map[default1:funcName3_param1 default2:funcName3_param2 myKey1:flowValue3-1 myKey2:flowValue3-2]
In FuncName = funcName3, FuncId = func-614511f5142e4023b80373517f3ea0a7, row = data from funcName[funcName2], index = 0
In FuncName = funcName3, FuncId = func-614511f5142e4023b80373517f3ea0a7, row = data from funcName[funcName2], index = 1
In FuncName = funcName3, FuncId = func-614511f5142e4023b80373517f3ea0a7, row = data from funcName[funcName2], index = 2
--- PASS: TestForkFlow (0.03s)
PASS
ok      kis-flow/test   0.996s

通过结果可以看出，flowClone1和flowName1具有相同的配置信息。

9.3 【V0.8】源代码

https://github.com/aceld/kis-flow/releases/tag/v0.8

作者:刘丹冰Aceld github: https://github.com/aceld
KisFlow开源项目地址：https://github.com/aceld/kis-flow

Golang框架实战-KisFlow流式计算框架专栏

Golang框架实战-KisFlow流式计算框架(1)-概述
Golang框架实战-KisFlow流式计算框架(2)-项目构建/基础模块-(上)
Golang框架实战-KisFlow流式计算框架(3)-项目构建/基础模块-(下)
Golang框架实战-KisFlow流式计算框架(4)-数据流
Golang框架实战-KisFlow流式计算框架(5)-Function调度
Golang框架实战-KisFlow流式计算框架(6)-Connector
Golang框架实战-KisFlow流式计算框架(7)-配置导入与导出
Golang框架实战-KisFlow流式计算框架(8)-KisFlow Action
Golang框架实战-KisFlow流式计算框架(10)-Flow多副本

刘丹冰(C++/Golang)
关注
  • 9
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Golang：在算法开发中的强大应用
BcpiDev的博客
09-22 17
在上面的示例代码中，我们使用了 goroutine 和 channel 来计算给定整数切片的总和。最后，我们使用 range 循环从结果通道中读取每个和，并将它们相加，得到最终的总和。在上面的示例代码中，我们使用了goroutine和channel来计算给定整数切片的总和。在本文中，我们将探讨为什么Golang是一个强大的算法开发工具，并提供一些示例代码来说明其在算法中的应用。此外，Golang的编译器和运行时环境针对高性能进行了优化，使得它的执行速度非常快，这对于处理大规模数据和复杂算法至关重要。
一个使用golang并行计算的例子
朱登凯的专栏
11-14 1349
sync.WaitGroup的工作方式类似java里面的CountDownLatch，用于计数并阻塞等待。 下面的例子，我们来编写一个并行任务，以并发的方式处理一个批次的任务，可以控制它的最大并发度，并在所有任务全部完成后返回一个结果。 import ( "fmt" "sync" "time" "unicode/utf8" ) func concurrentPrinting(tasks []string, maxConcurrent int) int { tokens := make(chan
golang常见的几种并发模型框架
Salted fish in hand, I have the world.
02-26 468
在golang中，经常使用协程做高并发，本文列举了几种常见并发模型。 package main import ( "fmt" "math/rand" "os" "runtime" "sync" "sync/atomic" "time" ) type Scenario struct { Name string ...
golang 并发与并行
魏菱延的博客
06-12 3444
一个线程是一个执行空间，这个空间会被操作系统调度来运行函数中所写的代码。每个进程至少包含一个线程，每个进程的初始线程被称作主线程。因为执行这个线程的空间是应用程序的本身的空间，所以当主线程终止时，应用程序也会终止。操作系统将线程调度到某个处理器上运行，这个处理器并不一定是进程所在的处理器。不同操作系统使用的线程调度算法一般都不一样，但是这种不同会被操作系统屏蔽，并不会展示给程序员。 操作系统会在物...
探秘BoomGo：高效、易用的并行计算框架
gitblog_00079的博客
04-04 341
探秘BoomGo：高效、易用的并行计算框架 项目地址:https://gitcode.com/BUPT-HJM/BoomGo BoomGo 是一个由北京邮电大学团队开发的开源并行计算框架，旨在简化分布式系统的开发过程，提高大规模数据处理效率。该项目基于Golang构建，充分利用了Go语言的并发特性，为开发者提供了一种轻量级、高性能的解决方案。 项目简介 BoomGo的核心设计理念是将复杂的并行计算...
Golang-Gin框架示例二十多个源码
04-26
在这个“Golang-Gin框架示例二十多个源码”中，你可以深入理解并学习如何利用Gin来构建各种类型的Web应用程序。 首先，Gin框架的核心概念是路由器。在Gin中，你可以通过简单的API定义路由，将HTTP请求映射到相应的...
Go-简单实用golang框架
08-13
"Go-简单实用golang框架"指的是在Go语言中用于构建Web应用的轻量级框架，这些框架使得开发过程更加高效和便捷。 Go语言中的Web框架主要分为两大类：MVC（Model-View-Controller）框架和微服务框架。MVC框架提供了一...
:pear:优雅的Golang Web框架-Golang开发
05-26
优雅的Golang Web框架注意：此存储库包含Goyave框架的核心代码。 如果要构建Goyave应用程序，请访问Goyave模板项目存储库。 Goyave是一个优雅的Golang Web框架注意：此存储库包含Goyave框架的核心代码。 如果要构建...
golang-graphql-benchmark：golang GraphQL框架的基准
02-04
golang-graphql-基准 版本中的graphql框架的基准。 版本：v0.7.9 版本：v0.0.0-20191219091308-23c3f22218ef 版本：v0.0.0-20200622220639-c1d9693c95a6 版本：v0.5.0 版本：v0.13.0 基准结果（2020/09/26） ...
golang微服务实战-go+micro+docker实现租房网系统（附详细教程）
最新发布
05-20
golang微服务实战-go+micro+docker实现租房网系统（附详细教程） 功能:用户注册，用户登录，头像上传，用户详细信息获取，实名认证检测，房源发布，首页展示，搜索房源，订单管理，用户评价等模块。 注:个人学习...
Golang框架实战-KisFlow流式计算框架(1)-概述
qq_40239222的博客
02-22 898
本人亲身经历过一个大规模的系统，多达上千个需要计算的业务数据字段，而早期因为没有规划好，最后导致存在1000+的脚本在定时跑，最后导致了脚本之间对数据的影响，数据始终无法准确，导致业务数据经常性的报数据问题错误。如下面一个场景：某个业务计算字段的值，正确为100，错误为99， 但是由于历史代码的臃肿，会有多个计算脚本对其值做修复补丁计算，会有各个脚本相互冲突，在一定的时间间隔内会存在数据值抖动，可能最终一个补丁修复正确，但是这种情况就会存在一定时间范围内业务数据不正确，最终却奇迹正确的情况，很让用户苦恼。
基于Golang的分布式数据运营与流式计算实战
走向CTO的路上...
05-26 1655
此外，Golang还提供了标准库中的encoding/json和encoding/gob包，可以方便地进行JSON和二进制数据的序列化和反序列化。在Golang中，我们可以使用各种分布式框架和工具，如etcd、consul、ZooKeeper等，来协调和管理分布式系统的节点和资源。基于Golang的分布式数据运营和流式计算系统具有高效、灵活和可伸缩的特点，可以帮助我们更好地处理大规模数据和实现业务需求。在实际开发中，我们需要结合具体业务场景和技术特点，进行合理的设计和优化，以达到最佳的性能和效果。
golang实现andflow流程引擎
u012474395的博客
11-28 2869
andflow_js可以实现在Html端设计流程，并将设计结果保存为json模型，andflow可以用于设计业务流程、数据处理流程、工作流、控制流等一切可流程化的过程。 采用golang实现一个具备高效、跨平台的andflow执行引擎。
golang flow工作流引擎-自己挖坑自己填
hotqin888的专栏
10-04 2199
Flow质量流程挖坑自己填 ——待完善 一、问题和坑 1.为何手机上添加后自己却看不到呢 因为手机登录后记录微信的openid，每个微信对应唯一的openid，不管这个微信切换哪个用户名来登录“鲁班宝”小程序，它都是一个openid。在engineercms这个服务端，它只记录这一个openid对应第一次登录的用户名。所以，不管用户切换哪个用户，小程序都只认第一次登录用的用户名。 因此，当用户添加文章后，小程序里要找出用户id，然后在addquality里将接收groupid设置为这个用户id，他
simple_flow一个简单的流式计算框架
finallygo的专栏
10-29 1022
simple_flow simple realtime flow computation 简介 simple_flow 是一个简单的实时流计算框架,由两部分组成,一个是agent,一个是flow_server, agent负责将数据实时传输给flow_server,flow_server负责对实时流的处理 特点 linux only 继承simple系列的传统,简洁实用 安全...
golang的极简流式编程实现
weixin_30390075的博客
01-29 152
传统的过程编码方式带来的弊端是显而易见，我们经常有这样的经验，一段时间不维护的代码或者别人的代码，突然拉回来看需要花费较长的时间，理解原来的思路，如果此时有个文档或者注释写的很好的话，可能花的时间会短一点，但是即便如此，很多调用关系也要反复确认才敢动手改动。下面是一断伪代码，描述过程编码方式： func A(){ B() C() } func B(){ ...
新一代流式计算框架在金融行业的应用
weixin_34092455的博客
10-12 314
大数据时代，数据计算已经渗透到了各行各业。业务沉淀数据，数据计算产生新的业务价值，数据计算正不断地用这种方式推动业务向前发展。大数据的计算模式主要分为批量计算(batch computing)、流式计算(stream computing)等，分别适用于不同的大数据应用场景。对于先存储后计算，实时性要求不高，同时数据规模大、计算模型复杂的应用场景，更适合使用批量计算。对于无需先存储，可以直接进行数...
【Flink流式计算框架】Flink数据源
一梦
07-28 402
005Flink 获取source的方式（自带的）        基于文件：readTextFile()        基于socket：socketTextStream        基于集合：fromCollection(Collection)        自定义数
leaf游戏服务器开发系列,Golang语言社区--游戏服务器框架 Leaf/go 分析
06-09
Leaf/go 是一个针对游戏服务器开发的 Golang 框架，它的设计目标是高性能、易扩展、易用性。以下是对该框架的分析： 1. 高性能：Leaf/go 中采用了 goroutine 和 channel 的方式进行协程通信，这种方式不仅能够避免...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值