锐客网

  1. 首页 > 生活百科 > it技术 > >

go语言吞吐量 go语言 cuda

IT技术连接

Golang web 框架对比由于 golang 提供了完善的net/http标准库，基于该标准库实现一个web框架的难度相比其他语言低了不少，所以go web框架简直就是百花齐放 。从老牌的revel和 beego ，到新出的 gin ，和 iris 等，而且还有一些类似于 chi 这种router 。个人一般小项目，尤其是中间件需要暴露一些http接口的，基本就使用chi即可 。
本次测试主要是gin iris echo 这三个框架 。侧重在于高性能，从并发和json序列化和反序列化两个方面来测评 ， 毕竟后台项目侧重的也就是这两个方面 。
为了选择符合重IO的框架，现设定如下场景的demo，demo的具体要求如下：
gin:
iris:
echo:
由于要测试5种body样本，4种场景，4个框架，因此把重点数据筛选出来(吞吐量、错误率和99%Line，重要性依次递减)，结果都绘制了图形 ， 方便比对查看 。
综合以上各个测试结果可以看出，gin以及iris都是非常优秀的框架，gin的优势比其他稍微大点，iris次之，而echo相应差一点 。
本次测试只是简单测试了一下3个框架的并发和json相关 。对比结果，不包括生态和工具的完善度等等 。如果测试有什么不完善的地方，欢迎交流 。
另外欢迎大家试用和star另外一个web框架 baa ，为了避嫌我没有贴出baa的数据，性能测试处于gin之后和iris之间 。
golang VS python性能谁更强？？？Go语言
Go是Google的Robert Griesemer，Rob Pike及Ken Thompson开发的一种静态强类型、编译型语言 。Go语言语法与C相近，但功能上有：内存安全、垃圾回收、结构形态及CSP-style并发计算 。
Go的语法接近C语言，但对于变量的声明有所不同 。Go支持垃圾回收功能 。Go的并行模型是以东尼·霍尔的通信顺序进程为基础，采取类似模型的其他语言包括Occam和Limbo，但它也具有Pi运算的特征，比如通道传输 。
Python
Python是一种广泛使用的具有动态语义的解释型、面向对象的高级编程语言 。
Python是一种面向对象的高级编程语言，具有集成的动态语义，主要用于Web和应用程序开发 。它在快速应用程序开发领域极具吸引力 ， 因为它提供动态类型和动态绑定选项 。
Python是一种解释型语言，这意味着用Python编写的程序不需要事先编译就可以运行 ， 从而可以轻松地测试小段代码并使用Python编写的代码更容易在平台之间移动 。
Go语言和Python的区别：
①语法：Python的语法使用缩进来指示代码块，Go的语言基于打开和关闭括号 。
②范例：Python是一种基于面向对象编程的多范式，命令式和函数式编程语言 。它坚持这样一种观点，即如果一种语言在某些情境中表现出某种特定的方式 ， 理想情况下它应该在所有情境中都有相似的作用 。但是，它又不是纯粹的OOP语言，它不支持强封装，这是OOP的主要原则之一 。Go是一种基于并发编程范式的过程编程语言，它与C具有表面相似性，实际上 ， Go更像是C的更新版本 。
③并发：Python没有提供内置的并发机制，而Go没有内置的并发机制 。
④类型化：Python是动态类型语言，而Go是一种静态类型语言，它实际上有助于在编译时捕获错误 ， 这可以进一步减少生产后期的严重错误 。
⑤安全性：Python是一种强类型语言，它是经过编译的，因此增加了一层安全性 。Go具有分配给每个变量的类型，因此，它提供了安全性 。但是，如果发生任何错误，用户需要自己运行整个代码 。
⑥管理内存：Go允许程序员在很大程度上管理内存 。而Python中的内存管理完全自动化并由Python VM管理;它不允许程序员对内存管理负责 。
⑦库：与Go相比，Python提供的库数量要大得多 。然而，Go仍然是新的，并且还没有取得很大进展 。
⑧速度：Go的速度远远超过Python 。
golang配制高性能sql.DB有很多教程是关于Go的sql.DB类型和如何使用它来执行SQL数据库查询的 。但大多数内容都没有讲述SetMaxOpenConns(),SetMaxIdleConns()和 SetConnMaxLifetime()方法，您可以使用它们来配置sql.DB的行为并改变其性能 。
转自：
整理：go语言中文文档：
在本文我将详细解释这些设置的作用 ， 并说明它们所能产生的(积极和消极)影响 。
一个sql.DB对象就是一个数据库连接池，它包含“正在用”和“空闲的”连接 。一个正在用的连接指的是，你正用它来执行数据库任务，例如执行SQL语句或行查询 。当任务完成连接就是空闲的 。
当您创建sql.DB执行数据库任务时，它将首先检查连接池中是否有可用的空闲连接 。如果有可用的连接，那么Go将重用现有连接，并在执行任务期间将其标记为正在使用 。如果池中没有空闲连接，而您需要一个空闲连接，那么Go将创建一个新的连接 。
默认情况下，在同一时间打开连接的数量是没有限制(包含使用中 空闲) 。但你可以通过SetMaxOpenConns()方法实现自定义限制，如下所示:
在这个示例代码中，连接池现在有5个并发打开的连接数 。如果所有5个连接都已经被标记为正在使用，并且需要另一个新的连接，那么应用程序将被迫等待 ， 直到5个连接中的一个被释放并变为空闲 。
为了说明更改MaxOpenConns的影响，我运行了一个基准测试，将最大打开连接数设置为1、2、5、10和无限 。基准测试在PostgreSQL数据库上执行并行的INSERT语句，您可以在这里找到代码 。测试结果:
对于这个基准测试 ， 我们可以看到，允许打开的连接越多，在数据库上执行INSERT操作所花费的时间就越少(打开的连接数为1时 ， 执行速度3129633ns/op，而无限连接：531030ns/op——大约快了6倍) 。这是因为允许打开的连接越多，可以并发执行的数据库查询就越多 。
默认情况下，sql.DB允许连接池中最多保留2个空闲连接 。你可以通过SetMaxIdleConns()方法改变它，如下所示:
从理论上讲 ， 允许池中有更多的空闲连接将提高性能，因为这样就不太可能从头开始建立新连接——因此有助于提升数据库性能 。
让我们来看看相同的基准测试 ， 最大空闲连接设置为none, 1,2,5和10:
当MaxIdleConns设置为none时，必须为每个INSERT从头创建一个新的连接，我们可以从基准测试中看到 ， 平均运行时和内存使用量相对较高 。
只允许保留和重用一个空闲连接对基准测试影响特别明显——它将平均运行时间减少了大约8倍，内存使用量减少了大约20倍 。继续增加空闲连接池的大小会使性能变得更好，尽管改进并不明显 。
那么 ， 您应该维护一个大的空闲连接池吗?答案取决于应用程序 。重要的是要意识到保持空闲连接是有代价的—它占用了可以用于应用程序和数据库的内存 。
还有一种可能是，如果一个连接空闲时间太长，那么它可能会变得不可用 。例如，MySQL的wait_timeout设置将自动关闭任何8小时(默认)内未使用的连接 。
当发生这种情况时，sql.DB会优雅地处理它 。坏连接将自动重试两次，然后放弃，此时Go将该连接从连接池中删除，并创建一个新的连接 。因此 ， 将MaxIdleConns设置得太大可能会导致连接变得不可用，与空闲连接池更小(使用更频繁的连接更少)相比，会占有更多的资源 。所以，如果你很可能很快就会再次使用，你只需保持一个空闲的连接 。
最后要指出的是，MaxIdleConns应该总是小于或等于MaxOpenConns 。Go强制执行此操作，并在必要时自动减少MaxIdleConns 。
现在让我们看看SetConnMaxLifetime()方法，它设置连接可重用的最大时间长度 。如果您的SQL数据库也实现了最大连接生命周期，或者—例如—您希望方便地在负载均衡器后交换数据库，那么这将非常有用 。
你可以这样使用它:
在这个例子中，所有的连接都将在创建后1小时“过期” ， 并且在过期后无法重用 。但注意:
从理论上讲，ConnMaxLifetime越短，连接过期的频率就越高——因此，需要从头创建连接的频率就越高 。为了说明这一点，我运行了将ConnMaxLifetime设置为100ms、200ms、500ms、1000ms和无限(永远重用)的基准测试，默认设置为无限打开连接和2个空闲连接 。这些时间段显然比您在大多数应用程序中使用的时间要短得多，但它们有助于很好地说明行为 。
在这些特定的基准测试中，我们可以看到 ， 与无限生存期相比，在100ms生存期时内存使用量增加了3倍以上，而且每个INSERT的平均运行时也稍微长一些 。
如果您在代码中设置了ConnMaxLifetime ， 那么一定要记住连接将过期(随后重新创建)的频率 。例如，如果您总共有100个连接，而ConnMaxLifetime为1分钟，那么您的应用程序可能每秒钟杀死和重新创建1.67个连接(平均值) 。您不希望这个频率太大，最终会阻碍性能 ， 而不是提高性能 。
最后，如果不说明超过数据库连接数量的硬限制将会发生什么 ， 那么本文就不完整了 。为了说明这一点，我将修改postgresql.conf文件，这样总共只允许5个连接(默认是100个)…
然后在无限连接的情况下重新运行基准测试……
一旦达到5个连接的硬限制 ， 数据库驱动程序(pq)立即返回一个太多客户端连接的错误消息，而无法完成INSERT 。为了防止这个错误 ， 我们需要将sql.DB中打开连接的最大总数(正在使用的 空闲的)设置为低于5 。像这样:
现在，sql.DB在任何时候最多只能创建3个连接，基准测试运行时应该不会出现任何错误 。但是这样做需要注意：当达到开放连接数限制，并且所有连接都在使用时，应用程序需要执行的任何新的数据库任务都将被迫等待，直到连接标记为空闲 。例如 ， 在web应用程序的上下文中，用户的HTTP请求看起来会“挂起”，甚至在等待数据库任务运行时可能会超时 。
为了减轻这种情况，你应该始终在一个上下文中传递 。在调用数据库时，启用上下文的方法(如ExecContext())，使用固定的、快速的超时上下文对象 。
总结
1、根据经验 ， 应该显式设置MaxOpenConns值 。这应该小于数据库和基础设施对连接数量的硬性限制 。
2、一般来说，更高的MaxOpenConns和MaxIdleConns值将带来更好的性能 。但你应该注意到效果是递减的，连接池空闲连接太多(连接没有被重用，最终会变坏)实际上会导致性能下降 。
3、为了降低上面第2点带来的风险，您可能需要设置一个相对较短的ConnMaxLifetime 。但你也不希望它太短，导致连接被杀死或不必要地频繁重建 。
4、MaxIdleConns应该总是小于或等于MaxOpenConns 。
对于中小型web应用程序，我通常使用以下设置作为起点，然后根据实际吞吐量水平的负载测试结果进行优化 。
如何在 Go 语言中使用 Redis 连接池一、关于连接池
一个数据库服务器只拥有有限的资源，并且如果你没有充分使用这些资源，你可以通过使用更多的连接来提高吞吐量 。一旦所有的资源都在使用，那么你就不 能通过增加更多的连接来提高吞吐量 。事实上，吞吐量在连接负载较大时就开始下降了 。通常可以通过限制与可用的资源相匹配的数据库连接的数量来提高延迟和吞 吐量 。
如何在Go语言中使用Redis连接池
如果不使用连接池，那么，每次传输数据，我们都需要进行创建连接，收发数据，关闭连接 。在并发量不高的场景，基本上不会有什么问题，一旦并发量上去了，那么，一般就会遇到下面几个常见问题：
性能普遍上不去
CPU 大量资源被系统消耗
网络一旦抖动，会有大量 TIME_WAIT 产生，不得不定期重启服务或定期重启机器
服务器工作不稳定，QPS 忽高忽低
要想解决这些问题，我们就要用到连接池了 。连接池的思路很简单 ， 在初始化时 ， 创建一定数量的连接，先把所有长连接存起来，然后，谁需要使用，从这里取走，干完活立马放回来 。如果请求数超出连接池容量 ， 那么就排队等待、退化成短连接或者直接丢弃掉 。
二、使用连接池遇到的坑
最近在一个项目中 ， 需要实现一个简单的 Web Server 提供 Redis 的 HTTP interface，提供 JSON 形式的返回结果 。考虑用 Go 来实现 。
首先，去看一下 Redis 官方推荐的 Go Redis driver 。官方 Star 的项目有两个：Radix.v2 和 Redigo 。经过简单的比较后，选择了更加轻量级和实现更加优雅的 Radix.v2 。
Radix.v2 包是根据功能划分成一个个的 sub package ， 每一个 sub package 在一个独立的子目录中，结构非常清晰 。我的项目中会用到的 sub package 有 redis 和 pool 。
由于我想让这种被 fork 的进程最好简单点，做的事情单一一些，所以，在没有深入去看 Radix.v2 的 pool 的实现之前 ， 我选择了自己实现一个 Redis pool 。(这里 ， 就不贴代码了 。后来发现自己实现的 Redis pool 与 Radix.v2 实现的 Redis pool 的原理是一样的 ， 都是基于 channel 实现的, 遇到的问题也是一样的 。)
不过在测试过程中，发现了一个诡异的问题 。在请求过程中经常会报 EOF 错误 。而且是概率性出现，一会有问题，一会又好了 。通过反复的测试，发现 bug 是有规律的 ， 当程序空闲一会后，再进行连续请求，会发生3次失败，然后之后的请求都能成功 ， 而我的连接池大小设置的是3 。再进一步分析，程序空闲300秒 后，再请求就会失败，发现我的 Redis server 配置了 timeout 300，至此 ， 问题就清楚了 。是连接超时 Redis server 主动断开了连接 。客户端这边从一个超时的连接请求就会得到 EOF 错误 。
然后我看了一下 Radix.v2 的 pool 包的源码，发现这个库本身并没有检测坏的连接 ， 并替换为新server{location/pool{content_by_lua_block{localredis=require"resty.redis"localred=redis:new()localok,err=red:connect("127.0.0.1",6379)ifnotokthenngx.say("failedtoconnect:",err)returnendok,err=red:set("hello","world")ifnotokthenreturnendred:set_keepalive(10000,100)}}}
发现有个 set_keepalive 的方法，查了一下官方文档，方法的原型是 syntax: ok, err = red:set_keepalive(max_idle_timeout, pool_size) 貌似 max_idle_timeout 这个参数，就是我们所缺少的东西，然后进一步跟踪源码，看看里面是怎么保证连接有效的 。
function_M.set_keepalive(self,...)localsock=self.sockifnotsockthenreturnnil,"notinitialized"endifself.subscribedthenreturnnil,"subscribedstate"endreturnsock:setkeepalive(...)end
至此，已经清楚了 ， 使用了 tcp 的 keepalive 心跳机制 。
于是 ， 通过与 Radix.v2 的作者一些讨论，选择自己在 redis 这层使用心跳机制，来解决这个问题 。
四、最后的解决方案
在创建连接池之后，起一个 goroutine ， 每隔一段 idleTime 发送一个 PING 到 Redis server 。其中，idleTime 略小于 Redis server 的 timeout 配置 。连接池初始化部分代码如下：
p,err:=pool.New("tcp",u.Host,concurrency)errHndlr(err)gofunc(){for{p.Cmd("PING")time.Sleep(idelTime*time.Second)}}()
使用 redis 传输数据部分代码如下：
funcredisDo(p*pool.Pool,cmdstring,args...interface{})(reply*redis.Resp,errerror){reply=p.Cmd(cmd,args...)iferr=reply.Err;err!=nil{iferr!=io.EOF{Fatal.Println("redis",cmd,args,"erris",err)}}return}
其中 ， Radix.v2 连接池内部进行了连接池内连接的获取和放回，代码如下：
//Cmdautomaticallygetsoneclientfromthepool,executesthegivencommand//(returningitsresult),andputstheclientbackinthepoolfunc(p*Pool)Cmd(cmdstring,args...interface{})*redis.Resp{c,err:=p.Get()iferr!=nil{returnredis.NewResp(err)}deferp.Put(c)returnc.Cmd(cmd,args...)}
这样，我们就有了 keepalive 的机制，不会出现 timeout 的连接了，从 redis 连接池里面取出的连接都是可用的连接了 。看似简单的代码，却完美的解决了连接池里面超时连接的问题 。同时，就算 Redis server 重启等情况 ， 也能保证连接自动重连 。
为什么 Go 语言的性能还不如javaGo语言自亮相以来并没有展示一个明确的方向，Google员工将Go语言称为一个“试验性语言” ， 称其试图融合Python等动态语言的开发速度和C或C等编译语言的性能和安全 。一位Go语言的支持者概括而言Go语言如下：简单、快速、安全、并发、快乐编程、开源；但Go语言缺乏方向以及其“集大成者”的尝试很容易会导致其学猫不成学狗也不成，沦为四不像 。尽管如此，编者仍然觉得Go语言有相当大的潜力：很多开发者对它感兴趣——不仅它的最初设计者阵容强大，而且在参与修改源代码的人群中也不乏大牛级人物 。这很有可能帮助Go语言找到适合自己的方向，开拓系统编程的新方向 。
golang使用Nsq1. 介绍
最近在研究一些消息中间件go语言吞吐量，常用的MQ如RabbitMQ,ActiveMQ,Kafka等 。NSQ是一个基于Go语言的分布式实时消息平台，它基于MIT开源协议发布，由bitly公司开源出来的一款简单易用的消息中间件 。
官方和第三方还为NSQ开发了众多客户端功能库，如官方提供的基于HTTP的nsqd、Go客户端go-nsq、Python客户端pynsq、基于Node.js的JavaScript客户端nsqjs、异步C客户端libnsq、Java客户端nsq-java以及基于各种语言的众多第三方客户端功能库 。
1.1 Features
1). Distributed
NSQ提供了分布式的，去中心化，且没有单点故障的拓扑结构，稳定的消息传输发布保障 ， 能够具有高容错和HA（高可用）特性 。
2). Scalable易于扩展
NSQ支持水平扩展，没有中心化的brokers 。内置的发现服务简化了在集群中增加节点 。同时支持pub-sub和load-balanced 的消息分发 。
3). Ops Friendly
NSQ非常容易配置和部署，生来就绑定了一个管理界面 。二进制包没有运行时依赖 。官方有Docker image 。
4.Integrated高度集成
官方的 Go 和 Python库都有提供 。而且为大多数语言提供了库 。
1.2 组件
1.3 拓扑结构
NSQ推荐通过他们相应的nsqd实例使用协同定位发布者，这意味着即使面对网络分区，消息也会被保存在本地，直到它们被一个消费者读取 。更重要的是 ， 发布者不必去发现其他的nsqd节点，他们总是可以向本地实例发布消息 。
NSQ
首先，一个发布者向它的本地nsqd发送消息 ， 要做到这点 ， 首先要先打开一个连接，然后发送一个包含topic和消息主体的发布命令，在这种情况下，我们将消息发布到事件topic上以分散到我们不同的worker中 。
事件topic会复制这些消息并且在每一个连接topic的channel上进行排队，在我们的案例中，有三个channel，它们其中之一作为档案channel 。消费者会获取这些消息并且上传到S3 。
nsqd
每个channel的消息都会进行排队，直到一个worker把他们消费 ， 如果此队列超出了内存限制，消息将会被写入到磁盘中 。Nsqd节点首先会向nsqlookup广播他们的位置信息 ， 一旦它们注册成功，worker将会从nsqlookup服务器节点上发现所有包含事件topic的nsqd节点 。
nsqlookupd
2. Internals
2.1 消息传递担保
1）客户表示已经准备好接收消息
2）NSQ 发送一条消息，并暂时将数据存储在本地（在 re-queue 或 timeout）
3）客户端回复 FIN（结束）或 REQ（重新排队）分别指示成功或失败 。如果客户端没有回复, NSQ 会在设定的时间超时，自动重新排队消息
这确保了消息丢失唯一可能的情况是不正常结束 nsqd 进程 。在这种情况下，这是在内存中的任何信息（或任何缓冲未刷新到磁盘）都将丢失 。
如何防止消息丢失是最重要的，即使是这个意外情况可以得到缓解 。一种解决方案是构成冗余 nsqd对（在不同的主机上）接收消息的相同部分的副本 。因为go语言吞吐量你实现的消费者是幂等的 ， 以两倍时间处理这些消息不会对下游造成影响，并使得系统能够承受任何单一节点故障而不会丢失信息 。
2.2 简化配置和管理
单个 nsqd 实例被设计成可以同时处理多个数据流 。流被称为“话题”和话题有 1 个或多个“通道” 。每个通道都接收到一个话题中所有消息的拷贝 。在实践中，一个通道映射到下行服务消费一个话题 。
在更底的层面，每个 nsqd 有一个与 nsqlookupd 的长期 TCP 连接，定期推动其状态 。这个数据被 nsqlookupd 用于给消费者通知 nsqd 地址 。对于消费者来说，一个暴露的 HTTP /lookup 接口用于轮询 。为话题引入一个新的消费者 ， 只需启动一个配置了 nsqlookup 实例地址的 NSQ 客户端 。无需为添加任何新的消费者或生产者更改配置，大大降低了开销和复杂性 。
2.3 消除单点故障
NSQ被设计以分布的方式被使用 。nsqd 客户端（通过 TCP ）连接到指定话题的所有生产者实例 。没有中间人，没有消息代理 ， 也没有单点故障 。
这种拓扑结构消除单链 ， 聚合，反馈 。相反，你的消费者直接访问所有生产者 。从技术上讲，哪个客户端连接到哪个 NSQ 不重要，只要有足够的消费者连接到所有生产者，以满足大量的消息，保证所有东西最终将被处理 。对于 nsqlookupd，高可用性是通过运行多个实例来实现 。他们不直接相互通信和数据被认为是最终一致 。消费者轮询所有的配置的 nsqlookupd 实例和合并 response 。失败的，无法访问的，或以其他方式故障的节点不会让系统陷于停顿 。
2.4 效率
对于数据的协议 ， 通过推送数据到客户端最大限度地提高性能和吞吐量的，而不是等待客户端拉数据 。这个概念 ， 称之为 RDY 状态 ， 基本上是客户端流量控制的一种形式 。
efficiency
2.5 心跳和超时
组合应用级别的心跳和 RDY 状态 ， 避免头阻塞现象 ， 也可能使心跳无用（即 ， 如果消费者是在后面的处理消息流的接收缓冲区中，操作系统将被填满，堵心跳）为了保证进度，所有的网络 IO 时间上限势必与配置的心跳间隔相关联 。这意味着，你可以从字面上拔掉之间的网络连接 nsqd 和消费者，它会检测并正确处理错误 。当检测到一个致命错误，客户端连接被强制关闭 。在传输中的消息会超时而重新排队等待传递到另一个消费者 。最后，错误会被记录并累计到各种内部指标 。
2.6 分布式
因为NSQ没有在守护程序之间共享信息，所以它从一开始就是为了分布式操作而生 。个别的机器可以随便宕机随便启动而不会影响到系统的其余部分 ， 消息发布者可以在本地发布，即使面对网络分区 。
这种“分布式优先”的设计理念意味着NSQ基本上可以永远不断地扩展，需要更高的吞吐量？那就添加更多的nsqd吧 。唯一的共享状态就是保存在lookup节点上，甚至它们不需要全局视图，配置某些nsqd注册到某些lookup节点上这是很简单的配置，唯一关键的地方就是消费者可以通过lookup节点获取所有完整的节点集 。清晰的故障事件——NSQ在组件内建立了一套明确关于可能导致故障的的故障权衡机制，这对消息传递和恢复都有意义 。虽然它们可能不像Kafka系统那样提供严格的保证级别，但NSQ简单的操作使故障情况非常明显 。
2.7 no replication
不像其他的队列组件，NSQ并没有提供任何形式的复制和集群 ， 也正是这点让它能够如此简单地运行，但它确实对于一些高保证性高可靠性的消息发布没有足够的保证 。我们可以通过降低文件同步的时间来部分避免，只需通过一个标志配置，通过EBS支持我们的队列 。但是这样仍然存在一个消息被发布后马上死亡，丢失了有效的写入的情况 。
2.8 没有严格的顺序
虽然Kafka由一个有序的日志构成，但NSQ不是 。消息可以在任何时间以任何顺序进入队列 。在我们使用的案例中，这通常没有关系，因为所有的数据都被加上了时间戳，但它并不适合需要严格顺序的情况 。
2.9 无数据重复删除功能
NSQ对于超时系统，它使用了心跳检测机制去测试消费者是否存活还是死亡 。很多原因会导致我们的consumer无法完成心跳检测，所以在consumer中必须有一个单独的步骤确保幂等性 。
3. 实践安装过程
本文将nsq集群具体的安装过程略去 ， 大家可以自行参考官网 ， 比较简单 。这部分介绍下笔者实验的拓扑，以及nsqadmin的相关信息 。
3.1 拓扑结构
topology
实验采用3台NSQD服务，2台LOOKUPD服务 。
采用官方推荐的拓扑 ， 消息发布的服务和NSQD在一台主机 。一共5台机器 。
NSQ基本没有配置文件，配置通过命令行指定参数 。
主要命令如下:
LOOKUPD命令
NSQD命令
工具类，消费后存储到本地文件 。
发布一条消息
3.2 nsqadmin
对Streams的详细信息进行查看，包括NSQD节点 ， 具体的channel，队列中的消息数，连接数等信息 。
nsqadmin
channel
列出所有的NSQD节点:
nodes
消息的统计:
msgs
lookup主机的列表:
hosts
4. 总结
NSQ基本核心就是简单性，是一个简单的队列 ， 这意味着它很容易进行故障推理和很容易发现bug 。消费者可以自行处理故障事件而不会影响系统剩下的其余部分 。
事实上，简单性是我们决定使用NSQ的首要因素，这方便与我们的许多其他软件一起维护，通过引入队列使我们得到了堪称完美的表现，通过队列甚至让我们增加了几个数量级的吞吐量 。越来越多的consumer需要一套严格可靠性和顺序性保障，这已经超过了NSQ提供的简单功能 。
结合我们的业务系统来看 ， 对于我们所需要传输的发票消息，相对比较敏感，无法容忍某个nsqd宕机，或者磁盘无法使用的情况，该节点堆积的消息无法找回 。这是我们没有选择该消息中间件的主要原因 。简单性和可靠性似乎并不能完全满足 。相比Kafka，ops肩负起更多负责的运营 。另一方面，它拥有一个可复制的、有序的日志可以提供给我们更好的服务 。但对于其他适合NSQ的consumer，它为我们服务的相当好，我们期待着继续巩固它的坚实的基础 。
【go语言吞吐量 go语言 cuda】关于go语言吞吐量和go语言 cuda的介绍到此就结束了 ， 不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站 。

    推荐阅读


    上一篇：不想看电视怎么做投影仪，不看电视怎么样

    下一篇：2037虚拟空间，虚拟空间官方下载优化版