go语言的rpc机制 go调用c函数

GoLang -- gRPC框架四大服务

在 gRPC 里客户端应用可以像调用本地对象一样直接调用另一台不同的机器上服务端应用的方法，使得您能够更容易地创建分布式应用和服务。与许多 RPC 系统类似，gRPC 也是基于以下理念：定义一个服务，指定其能够被远程调用的方法（包含参数和返回类型）。在服务端实现这个接口，并运行一个 gRPC 服务器来处理客户端调用。在客户端拥有一个存根能够像服务端一样的方法。

为保康等地区用户提供了全套网页设计制作服务，及保康网站建设行业解决方案。主营业务为做网站、成都网站建设、保康网站设计，以传统方式定制建设网站，并提供域名空间备案等一条龙服务，秉承以专业、用心的态度为用户提供真诚的服务。我们深信只要达到每一位用户的要求，就会得到认可，从而选择与我们长期合作。这样，我们也可以走得更远！

gRPC 客户端和服务端可以在多种环境中运行和交互 - 从 google 内部的服务器到你自己的笔记本，并且可以用任何 gRPC 支持的语言来编写。所以，你可以很容易地用 Java 创建一个 gRPC 服务端，用 Go、Python、Ruby 来创建客户端。此外，Google 最新 API 将有 gRPC 版本的接口，使你很容易地将 Google 的功能集成到你的应用里。

gRPC 默认使用 protocol buffers，这是 Google 开源的一套成熟的结构数据序列化机制（当然也可以使用其他数据格式如 JSON）。名叫 proto3 的新风格的 protocol buffers，它拥有轻量简化的语法、一些有用的新功能，并且支持更多新语言。当前针对 Java 和 C++ 发布了 beta 版本，针对 JavaNano（即 Android Java）发布 alpha 版本，在protocol buffers Github 源码库里有 Ruby 支持，在golang/protobuf Github 源码库里还有针对 Go 语言的生成器，对更多语言的支持正在开发中。

有了 gRPC，我们可以一次性的在一个 .proto 文件中定义服务并使用任何支持它的语言去实现客户端和服务器，反过来，它们可以在各种环境中，从Google的服务器到你自己的平板电脑—— gRPC 帮你解决了不同语言及环境间通信的复杂性.使用 protocol buffers 还能获得其他好处，包括高效的序列号，简单的 IDL 以及容易进行接口更新。

现在让我们来仔细了解一下当 gRPC 客户端调用 gRPC 服务端的方法时到底发生了什么。我们不究其实现细节，关于实现细节的部分，你可以在我们的特定语言页面里找到更为详尽的内容。

首先我们来了解一下最简单的 RPC 形式：客户端发出单个请求，获得单个响应。

服务端流式 RPC 除了在得到客户端请求信息后发送回一个应答流之外，与我们的简单例子一样。在发送完所有应答后，服务端的状态详情(状态码和可选的状态信息)和可选的跟踪元数据被发送回客户端，以此来完成服务端的工作。客户端在接收到所有服务端的应答后也完成了工作。

客户端流式 RPC 也基本与我们的简单例子一样，区别在于客户端通过发送一个请求流给服务端，取代了原先发送的单个请求。服务端通常（但并不必须）会在接收到客户端所有的请求后发送回一个应答，其中附带有它的状态详情和可选的跟踪数据。

双向流式 RPC ，调用由客户端调用方法来初始化，而服务端则接收到客户端的元数据，方法名和截止时间。服务端可以选择发送回它的初始元数据或等待客户端发送请求。下一步怎样发展取决于应用，因为客户端和服务端能在任意顺序上读写 - 这些流的操作是完全独立的。例如服务端可以一直等直到它接收到所有客户端的消息才写应答，或者服务端和客户端可以像"乒乓球"一样：服务端后得到一个请求就回送一个应答，接着客户端根据应答来发送另一个请求，以此类推。

通过运行下面的命令克隆并安装grpc-go代码库：

下载protobuf源码包

安装golang-protobuf

第一步使用 protocol buffers去定义 gRPC service 和方法 request 以及 response 的类型。

要定义一个服务，必须在.proto 文件中指定 service：

然后在服务中定义 rpc 方法，指定请求的和响应类型，gRPC 允许定义4种类型的 service 方法。

服务.proto文件如下所示：

一学就会，手把手教你用Go语言调用智能合约

智能合约调用是实现一个 DApp 的关键，一个完整的 DApp 包括前端、后端、智能合约及区块链系统，智能合约的调用是连接区块链与前后端的关键。

我们先来了解一下智能合约调用的基础原理。智能合约运行在以太坊节点的 EVM 中。因此要想调用合约必须要访问某个节点。

以后端程序为例，后端服务若想连接节点有两种可能，一种是双方在同一主机，此时后端连接节点可以采用本地 IPC(Inter-Process Communication，进程间通信)机制，也可以采用 RPC(Remote Procedure Call，远程过程调用)机制;另一种情况是双方不在同一台主机，此时只能采用 RPC 机制进行通信。

提到 RPC，读者应该对 Geth 启动参数有点印象，Geth 启动时可以选择开启 RPC 服务，对应的默认服务端口是 8545。。

接着，我们来了解一下智能合约运行的过程。

智能合约的运行过程是后端服务连接某节点，将智能合约的调用(交易)发送给节点，节点在验证了交易的合法性后进行全网广播，被矿工打包到区块中代表此交易得到确认，至此交易才算完成。

就像数据库一样，每个区块链平台都会提供主流开发语言的 SDK(Software Development Kit，软件开发工具包)，由于 Geth 本身就是用 Go 语言编写的，因此若想使用 Go 语言连接节点、发交易，直接在工程内导入 go-ethereum(Geth 源码) 包就可以了，剩下的问题就是流程和 API 的事情了。

总结一下，智能合约被调用的两个关键点是节点和 SDK。

由于 IPC 要求后端与节点必须在同一主机，所以很多时候开发者都会采用 RPC 模式。除了 RPC，以太坊也为开发者提供了 json- rpc 接口，本文就不展开讨论了。

接下来介绍如何使用 Go 语言，借助 go-ethereum 源码库来实现智能合约的调用。这是有固定步骤的，我们先来说一下总体步骤，以下面的合约为例。

步骤 01:编译合约，获取合约 ABI(Application Binary Interface，应用二进制接口)。单击【ABI】按钮拷贝合约 ABI 信息，将其粘贴到文件 calldemo.abi 中(可使用 Go 语言IDE 创建该文件，文件名可自定义，后缀最好使用 abi)。

最好能将 calldemo.abi 单独保存在一个目录下，输入“ls”命令只能看到 calldemo.abi 文件，参考效果如下:

步骤 02:获得合约地址。注意要将合约部署到 Geth 节点。因此 Environment 选择为 Web3 Provider。

在【Environment】选项框中选择“Web3 Provider”，然后单击【Deploy】按钮。

部署后，获得合约地址为:0xa09209c28AEf59a4653b905792a9a910E78E7407。

步骤 03:利用 abigen 工具(Geth 工具包内的可执行程序)编译智能合约为 Go 代码。abigen 工具的作用是将 abi 文件转换为 Go 代码，命令如下:

其中各参数的含义如下。 (1)abi:是指定传入的 abi 文件。 (2)type:是指定输出文件中的基本结构类型。 (3)pkg:指定输出文件 package 名称。 (4)out:指定输出文件名。执行后，将在代码目录下看到 funcdemo.go 文件，读者可以打开该文件欣赏一下，注意不要修改它。

步骤 04:创建 main.go，填入如下代码。注意代码中 HexToAddress 函数内要传入该合约部署后的地址，此地址在步骤 01 中获得。

步骤 04:设置 go mod，以便工程自动识别。

前面有所提及，若要使用 Go 语言调用智能合约，需要下载 go-ethereum 工程，可以使用下面的指令:

该指令会自动将 go-ethereum 下载到“$GOPATH/src/github.com/ethereum/go-ethereum”，这样还算不错。不过，Go 语言自 1.11 版本后，增加了 module 管理工程的模式。只要设置好了 go mod，下载依赖工程的事情就不必关心了。

接下来设置 module 生效和 GOPROXY，命令如下:

在项目工程内，执行初始化，calldemo 可以自定义名称。

步骤 05:运行代码。执行代码，将看到下面的效果，以及最终输出的 2020。

上述输出信息中，可以看到 Go 语言会自动下载依赖文件，这就是 go mod 的神奇之处。看到 2020，相信读者也知道运行结果是正确的了。

【golang详解】go语言GMP(GPM)原理和调度

Goroutine调度是一个很复杂的机制，下面尝试用简单的语言描述一下Goroutine调度机制，想要对其有更深入的了解可以去研读一下源码。

首先介绍一下GMP什么意思：

G ----------- goroutine: 即Go协程，每个go关键字都会创建一个协程。

M ---------- thread内核级线程，所有的G都要放在M上才能运行。

P ----------- processor处理器，调度G到M上，其维护了一个队列，存储了所有需要它来调度的G。

Goroutine 调度器P和 OS 调度器是通过 M 结合起来的，每个 M 都代表了 1 个内核线程，OS 调度器负责把内核线程分配到 CPU 的核上执行

模型图：

避免频繁的创建、销毁线程，而是对线程的复用。

1）work stealing机制

当本线程无可运行的G时，尝试从其他线程绑定的P偷取G，而不是销毁线程。

2）hand off机制

当本线程M0因为G0进行系统调用阻塞时，线程释放绑定的P，把P转移给其他空闲的线程执行。进而某个空闲的M1获取P，继续执行P队列中剩下的G。而M0由于陷入系统调用而进被阻塞，M1接替M0的工作，只要P不空闲，就可以保证充分利用CPU。M1的来源有可能是M的缓存池，也可能是新建的。当G0系统调用结束后，根据M0是否能获取到P，将会将G0做不同的处理：

如果有空闲的P，则获取一个P，继续执行G0。

如果没有空闲的P，则将G0放入全局队列，等待被其他的P调度。然后M0将进入缓存池睡眠。

如下图

GOMAXPROCS设置P的数量，最多有GOMAXPROCS个线程分布在多个CPU上同时运行

在Go中一个goroutine最多占用CPU 10ms，防止其他goroutine被饿死。

具体可以去看另一篇文章

【Golang详解】go语言调度机制抢占式调度

当创建一个新的G之后优先加入本地队列，如果本地队列满了，会将本地队列的G移动到全局队列里面，当M执行work stealing从其他P偷不到G时，它可以从全局G队列获取G。

协程经历过程

我们创建一个协程 go func()经历过程如下图：

说明：

这里有两个存储G的队列，一个是局部调度器P的本地队列、一个是全局G队列。新创建的G会先保存在P的本地队列中，如果P的本地队列已经满了就会保存在全局的队列中；处理器本地队列是一个使用数组构成的环形链表，它最多可以存储 256 个待执行任务。

G只能运行在M中，一个M必须持有一个P，M与P是1：1的关系。M会从P的本地队列弹出一个可执行状态的G来执行，如果P的本地队列为空，就会想其他的MP组合偷取一个可执行的G来执行；

一个M调度G执行的过程是一个循环机制；会一直从本地队列或全局队列中获取G

上面说到P的个数默认等于CPU核数，每个M必须持有一个P才可以执行G，一般情况下M的个数会略大于P的个数，这多出来的M将会在G产生系统调用时发挥作用。类似线程池，Go也提供一个M的池子，需要时从池子中获取，用完放回池子，不够用时就再创建一个。

work-stealing调度算法：当M执行完了当前P的本地队列队列里的所有G后，P也不会就这么在那躺尸啥都不干，它会先尝试从全局队列队列寻找G来执行，如果全局队列为空，它会随机挑选另外一个P，从它的队列里中拿走一半的G到自己的队列中执行。

如果一切正常，调度器会以上述的那种方式顺畅地运行，但这个世界没这么美好，总有意外发生，以下分析goroutine在两种例外情况下的行为。

Go runtime会在下面的goroutine被阻塞的情况下运行另外一个goroutine：

用户态阻塞/唤醒

当goroutine因为channel操作或者network I/O而阻塞时（实际上golang已经用netpoller实现了goroutine网络I/O阻塞不会导致M被阻塞，仅阻塞G，这里仅仅是举个栗子），对应的G会被放置到某个wait队列(如channel的waitq)，该G的状态由_Gruning变为_Gwaitting，而M会跳过该G尝试获取并执行下一个G，如果此时没有可运行的G供M运行，那么M将解绑P，并进入sleep状态；当阻塞的G被另一端的G2唤醒时（比如channel的可读/写通知），G被标记为，尝试加入G2所在P的runnext（runnext是线程下一个需要执行的 Goroutine。），然后再是P的本地队列和全局队列。

系统调用阻塞

当M执行某一个G时候如果发生了阻塞操作，M会阻塞，如果当前有一些G在执行，调度器会把这个线程M从P中摘除，然后再创建一个新的操作系统的线程(如果有空闲的线程可用就复用空闲线程)来服务于这个P。当M系统调用结束时候，这个G会尝试获取一个空闲的P执行，并放入到这个P的本地队列。如果获取不到P，那么这个线程M变成休眠状态，加入到空闲线程中，然后这个G会被放入全局队列中。

队列轮转

可见每个P维护着一个包含G的队列，不考虑G进入系统调用或IO操作的情况下，P周期性的将G调度到M中执行，执行一小段时间，将上下文保存下来，然后将G放到队列尾部，然后从队列中重新取出一个G进行调度。

除了每个P维护的G队列以外，还有一个全局的队列，每个P会周期性地查看全局队列中是否有G待运行并将其调度到M中执行，全局队列中G的来源，主要有从系统调用中恢复的G。之所以P会周期性地查看全局队列，也是为了防止全局队列中的G被饿死。

M0是启动程序后的编号为0的主线程，这个M对应的实例会在全局变量rutime.m0中，不需要在heap上分配，M0负责执行初始化操作和启动第一个G，在之后M0就和其他的M一样了

G0是每次启动一个M都会第一个创建的goroutine，G0仅用于负责调度G，G0不指向任何可执行的函数，每个M都会有一个自己的G0，在调度或系统调用时会使用G0的栈空间，全局变量的G0是M0的G0

一个G由于调度被中断，此后如何恢复？

中断的时候将寄存器里的栈信息，保存到自己的G对象里面。当再次轮到自己执行时，将自己保存的栈信息复制到寄存器里面，这样就接着上次之后运行了。

我这里只是根据自己的理解进行了简单的介绍，想要详细了解有关GMP的底层原理可以去看Go调度器 G-P-M 模型的设计者的文档或直接看源码

参考： ()

()

go websocket 问题（Hijacker）

在写websocket包的时候发现一个比较有趣问题！go 使用 TLS验证的时候发现 websocket 使用不了。深入了解发现其中奥秘：go 在执行 TLS 验证时候默认是使用 http2 协议进行的！但是 websocket 是无法支持 http2 协议（暂时），导致这个问题所在的原因！

使用空 map 来使用 http1.x协议

因为默认支持h2，所有我们把降到http1.x。

使用 http.Hijacker 对其进行劫持 net.Conn , 让程序员自己控制使用！其实这个时候已经脱离 http 协议规范！

发现使用 Hijacker 会脱离 http 协议范畴，可以解决h2与websocket的相关问题！

协议：状态码：101 , Upgrade , Connection, Sec-WebSocket-Accept

实现最简单 websocket 连接！

websocket连接已经建立，有些 sec 是默认添加上去！

根据 http.Listen 进行向下追踪

在 func (srv *Server) Serve(l net.Listener) error 发现原由

对 c.setState 进入分析

发现当 case 是 Hijack【StateHijacked, StateClosed】状态时候执行 trackConn

add 为 false ，对其 delete(s.activeConn,c) 。Hijacker是满足相关条件

所以在 go c.serve(connCtx) 里面不在给 Hijacker 进行操作！导致 http header 无法设置！最后交给程序员自己操作！

go中自带的rpc可以直接复用http server处理请求的那一套流程去创建连接，连接创建完毕后再使用Hijack方法拿到连接。

注: github.com/gorilla/websocket

这包就接入 HIjacker ，直接使用现成包就香~~~~~

为什么go语言适合开发网游服务器端

前段时间在golang-China读到这个贴：

个人觉得golang十分适合进行网游服务器端开发，写下这篇文章总结一下。

从网游的角度看：

要成功的运营一款网游，很大程度上依赖于玩家自发形成的社区。只有玩家自发形成一个稳定的生态系统，游戏才能持续下去，避免鬼城的出现。而这就需要多次大量导入用户，在同时在线用户量达到某个临界点的时候，才有可能完成。因此，多人同时在线十分有必要。

再来看网游的常见玩法，除了排行榜这类统计和数据汇总的功能外，基本没有需要大量CPU时间的应用。以前的项目里，即时战斗产生的各种伤害计算对CPU的消耗也不大。玩家要完成一次操作，需要通过客户端-服务器端-客户端这样一个来回，为了获得高响应速度，满足玩家体验，服务器端的处理也不能占用太多时间。所以，每次请求对应的CPU占用是比较小的。

网游的IO主要分两个方面，一个是网络IO，一个是磁盘IO。网络IO方面，可以分成美术资源的IO和游戏逻辑指令的IO，这里主要分析游戏逻辑的IO。游戏逻辑的IO跟CPU占用的情况相似，每次请求的字节数很小，但由于多人同时在线，因此并发数相当高。另外，地图信息的广播也会带来比较频繁的网络通信。磁盘IO方面，主要是游戏数据的保存。采用不同的数据库，会有比较大的区别。以前的项目里，就经历了从MySQL转向MongoDB这种内存数据库的过程，磁盘IO不再是瓶颈。总体来说，还是用内存做一级缓冲，避免大量小数据块读写的方案。

针对网游的这些特点，golang的语言特性十分适合开发游戏服务器端。

首先，go语言提供goroutine机制作为原生的并发机制。每个goroutine所需的内存很少，实际应用中可以启动大量的goroutine对并发连接进行响应。goroutine与gevent中的greenlet很相像，遇到IO阻塞的时候，调度器就会自动切换到另一个goroutine执行，保证CPU不会因为IO而发生等待。而goroutine与gevent相比，没有了python底层的GIL限制，就不需要利用多进程来榨取多核机器的性能了。通过设置最大线程数，可以控制go所启动的线程，每个线程执行一个goroutine，让CPU满负载运行。

同时，go语言为goroutine提供了独到的通信机制channel。channel发生读写的时候，也会挂起当前操作channel的goroutine，是一种同步阻塞通信。这样既达到了通信的目的，又实现同步，用CSP模型的观点看，并发模型就是通过一组进程和进程间的事件触发解决任务的。虽然说，主流的编程语言之间，只要是图灵完备的，他们就都能实现相同的功能。但go语言提供的这种协程间通信机制，十分优雅地揭示了协程通信的本质，避免了以往锁的显式使用带给程序员的心理负担，确是一大优势。进行网游开发的程序员，可以将游戏逻辑按照单线程阻塞式的写，不需要额外考虑线程调度的问题，以及线程间数据依赖的问题。因为，线程间的channel通信，已经表达了线程间的数据依赖关系了，而go的调度器会给予妥善的处理。

另外，go语言提供的gc机制，以及对指针的保护式使用，可以大大减轻程序员的开发压力，提高开发效率。

展望未来，我期待go语言社区能够提供更多的goroutine间的隔离机制。个人十分推崇erlang社区的脆崩哲学，推动应用发生预期外行为时，尽早崩溃，再fork出新进程处理新的请求。对于协程机制，需要由程序员保证执行的函数不会发生死循环，导致线程卡死。如果能够定制goroutine所执行函数的最大CPU执行时间，及所能使用的最大内存空间，对于提升系统的鲁棒性，大有裨益。

Go微服务--常见的微服务框架

近几年诞生了很多微服务框架，比如JAVA的Spring Cloud、Dubbo;Golang的GoKit和GoMicro以及NodeJs的Seneca。几乎每种主流语言都有其对应的微服务框架。

Go在微服务框架中有其独特的优势，至于优势在哪，自行google。

1、GoKit框架

这是一个工具包的集合，可以帮助攻城狮构建强大、可靠和可维护的微服务。提供了用于实现系统监控和弹性模式组件的库，例如日志、跟踪、限流、熔断等。

基于这个框架的应用程序架构由三个主要的部分组成：

传输层：用于网络通信，服务通常使用HTTP或者gRPC等网络传输协议，或者使用NATS等发布订阅系统相互通信。

接口层：是服务器和客户端的基本构建块。每个对外提供的接口方法都会定义为一个Endpoint，一遍在服务器和客户端之间进行网络通信，每个端点使用传输层通过HTTP或gRPC等具体通信模式对外提供服务

服务成：具体的业务逻辑实现

2、GoMicro框架

这是一个基于Go语言实现的插件化RPC微服务框架。提供了服务发现、负载均衡、同步传输、异步通信以及事件驱动等机制，尝试简化分布式系统之间的通信，让开发者更专注于自身业务逻辑的开发。

GoMicro的设计哲学是可插拔的架构理念，提供了可快速构建系统的组件，并且可以根据自身的需求对GoMicro提供的默认实现进行定制。所有插件都可在仓库github.com/micro/go-plugins 中找到。

新闻标题：go语言的rpc机制 go调用c函数
标题URL：http://mswzjz.cn/article/hgcodi.html

网站建设知识