像跟踪分布式服务调用那样跟踪Go函数调用链

最新推荐文章于 2024-08-06 16:38:18 发布
原创 最新推荐文章于 2024-08-06 16:38:18 发布 · 615 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#go #golang #gwt #c语言 #软件开发


本文首发于“gopher部落”知识星球 - https://articles.zsxq.com/id_h1bgd91iewub.html

这篇文章的初衷是想解答知乎上的一位知友提出的问题。没想到完成一种实现后，这个问题居然被删除了。那么既然实现了，就分享出来吧。问题的原文找不到了，问题大致是这样的：


一个程序中存在多个函数调用链都调用了函数D：

A1 -> B1 > C1 -> D

A2 -> B2 > C2 -> D

A3 -> B3 -> C3 -> D

... ...

那么，如果某次函数D被调用时出现了问题，那么怎么知道这个D是哪个函数调用链里的D呢？

有些gopher可能会说通过Delve在线调试(https://www.imooc.com/read/87/article/2465)打印函数调用栈可以知晓D的调用链，还有些gopher可能会说通过各个函数中输出的业务日志可以查明出问题的D归属的函数调用链，这些都是可行的思路。

不过当遇到这个问题时，我大脑中的第一反应却是能否像跟踪分布式服务调用链那样跟踪函数调用链呢？于是就有了本文对这种思路的一个非生产级的实现以及其演化过程。

1. 利用defer实现函数出入口的跟踪

跟踪函数调用，我们首先想到的就是跟踪函数的出入口，而完成这一任务，当仁不让的就是利用defer。对于我这样的从C语言转到Go的gopher而言，defer是我十分喜欢的Go“语法糖”，因为它可以简化代码的实现，让代码逻辑更清晰，具有更好地可读性(关于defer让代码更清晰的系统描述，可参考我的Go进阶技术专栏文章：https://www.imooc.com/read/87/article/2421)。

下面我们就来看看第一版函数跟踪实现的代码：

// github.com/bigwhite/experiments/blob/master/trace-function-call-chain/trace1/trace.go
func trace() func() {
 pc, _, _, ok := runtime.Caller(1)
 if !ok {
  panic("not found caller")
 }

 fn := runtime.FuncForPC(pc)
 name := fn.Name()

 fmt.Printf("enter: %s\n", name)
 return func() { fmt.Printf("exit: %s\n", name) } 
}

// github.com/bigwhite/experiments/blob/master/trace-function-call-chain/trace1/main.go
func A1() {
 defer trace()()
 B1()
}

func B1() {
 defer trace()()
 C1()
}

func C1() {
 defer trace()()
 D()
}

func D() {
 defer trace()()
}

func main() {
 A1()
}

我们看到：以A1实现为例，当执行流来带defer语句时，首先会对defer后面的表达式进行求值。trace函数会执行，输出函数入口信息，并返回一个“打印出口信息”的匿名函数。该函数在此并不会执行，而是被注册到函数A1的defer函数栈中，待A1函数执行结束后才会被弹出执行。也就是在A1结束后，会有一条函数的出口信息被输出。

下面我们来真实运行一下上面的trace1示例(Go 1.14, macOS 10.14.6)：

// github.com/bigwhite/experiments/trace-function-call-chain/trace1
$go build
$./functrace-demo
enter: main.A1
enter: main.B1
enter: main.C1
enter: main.D
exit: main.D
exit: main.C1
exit: main.B1
exit: main.A1

我们看到各个函数的出入口信息都被输出了，在单Goroutine的情况下，我们从执行顺序上能识别出D究竟是归属于哪个调用链的。

2. 添加trace开关

对函数调用链进行Trace是有一定性能损耗的，我们可能并不想在所有场合都开启trace，那么我们来给Trace添加一个“开关”，我们利用go build tags来实现这个功能特性：


// github.com/bigwhite/experiments/blob/master/trace-function-call-chain/trace2/trace.go

// +build trace

package main
... ...


// github.com/bigwhite/experiments/blob/master/trace-function-call-chain/trace2/trace_nop.go

// +build !trace

package main

func trace() func() {
 return func() {

 }
}

我们新增一个名为trace_nop.go的文件，里面包含了一个trace函数的空实现，即在trace函数与其返回的匿名函数中什么都不做。该源文件增加了一个build指示器(directive)：

// +build !trace

即在关闭trace开关时，使用该文件中的trace函数。而原trace.go文件中也增加了一个build指示器：

// +build trace

即只有在打开trace开关的情况下，才会使用该源文件。

我们来对比一下在trace开关打开和关闭下的执行结果：

// github.com/bigwhite/experiments/trace-function-call-chain/trace2
// trace开关关闭
$go build
$./functrace-demo

vs.

// trace开关打开
$go build -tags trace
$./functrace-demo
enter: main.A1
enter: main.B1
enter: main.C1
enter: main.D
exit: main.D
exit: main.C1
exit: main.B1
exit: main.A1

不过这里的实现还是有一个问题的，那就是即便不开启trace开关，trace_nop.go中的trace函数也是会被编译到可执行程序中的。利用go tool compile -S查看汇编代码，trace_nop.go中的trace函数以及其返回的匿名函数都没有被inline掉。这会带来一定的运行时开销，这个问题我们先记下并留到后面解决。

3. 增加对多goroutine函数调用链的跟踪支持

前面的实现面对只有一个goroutine的时候还是可以支撑的，但当程序中并发运行多个goroutine的时候，多个函数调用链的出入口信息输出就会混杂在一起无法分辨。下面我们就来改造一下实现，增加对多goroutine函数调用链的跟踪支持。我们的方案就是在输出函数出入口信息时，带上一个在程序每次执行时能唯一区分goroutine的goroutine id：

// github.com/bigwhite/experiments/blob/master/trace-function-call-chain/trace3/trace.go
func getGID() uint64 {
 b := make([]byte, 64)
 b = b[:runtime.Stack(b, false)]
 b = bytes.TrimPrefix(b, []byte("goroutine "))
 b = b[:bytes.IndexByte(b, ' ')]
 n, _ := strconv.ParseUint(string(b), 10, 64)
 return n
}

func trace() func() {
 pc, _, _, ok := runtime.Caller(1)
 if !ok {
  panic("not found caller")
 }

 fn := runtime.FuncForPC(pc)
 name := fn.Name()

 id := getGID()
 fmt.Printf("g[%02d]: enter %s\n", id, name)
 return func() { fmt.Printf("g[%02d]: exit %s\n", id, name) } 
}

main.go也改成了启动多个Goroutine：

// github.com/bigwhite/experiments/blob/master/trace-function-call-chain/trace3/main.go

func A1() {
 defer trace()()
 B1()
}

func B1() {
 defer trace()()
 C1()
}

func C1() {
 defer trace()()
 D()
}

func D() {
 defer trace()()
}

func A2() {
 defer trace()()
 B2()
}
func B2() {
 defer trace()()
 C2()
}
func C2() {
 defer trace()()
 D()
}

func main() {
 var wg sync.WaitGroup
 wg.Add(1)
 go func() {
  A2()
  wg.Done()
 }()

 time.Sleep(time.Millisecond * 50)
 A1()
 wg.Wait()
}

在trace功能开关打开的前提下，运行上面例子：

// github.com/bigwhite/experiments/trace-function-call-chain/trace3
$go build -tags trace
$./functrace-demo
g[18]: enter main.A2
g[18]: enter main.B2
g[18]: enter main.C2
g[18]: enter main.D
g[18]: exit main.D
g[18]: exit main.C2
g[18]: exit main.B2
g[18]: exit main.A2
g[01]: enter main.A1
g[01]: enter main.B1
g[01]: enter main.C1
g[01]: enter main.D
g[01]: exit main.D
g[01]: exit main.C1
g[01]: exit main.B1
g[01]: exit main.A1

4. 让输出更美观一些

了解分布式服务调用跟踪的童鞋都知道，通过带有层次感的输出，我们可以很容易识别出某个服务在哪个环节被调用。而上面我们的Trace输出太扁平，没有层次感，不容易识别，我们这里就来美化一下输出。我们将trace.go做如下改造：


// github.com/bigwhite/experiments/trace-function-call-chain/trace4/trace.go

var mu sync.Mutex
var m = make(map[uint64]int)

func printTrace(id uint64, name, typ string, indent int) {
 indents := ""
 for i := 0; i < indent; i++ {
  indents += "\t"
 }
 fmt.Printf("g[%02d]:%s%s%s\n", id, indents, typ, name)
}

func trace() func() {
 pc, _, _, ok := runtime.Caller(1)
 if !ok {
  panic("not found caller")
 }

 id := getGID()
 fn := runtime.FuncForPC(pc)
 name := fn.Name()

 mu.Lock()
 v := m[id]
 m[id] = v + 1
 mu.Unlock()
 printTrace(id, name, "->", v+1)
 return func() {
  mu.Lock()
  v := m[id]
  m[id] = v - 1
  mu.Unlock()
  printTrace(id, name, "<-", v)
 }
}

编译运行：

// github.com/bigwhite/experiments/trace-function-call-chain/trace4
$go build -tags trace
$./functrace-demo
g[18]: ->main.A2
g[18]:  ->main.B2
g[18]:   ->main.C2
g[18]:    ->main.D
g[18]:    <-main.D
g[18]:   <-main.C2
g[18]:  <-main.B2
g[18]: <-main.A2
g[01]: ->main.A1
g[01]:  ->main.B1
g[01]:   ->main.C1
g[01]:    ->main.D
g[01]:    <-main.D
g[01]:   <-main.C1
g[01]:  <-main.B1
g[01]: <-main.A1

这回显然好看多了，也更容易定位问题了！（当多个goroutine的函数跟踪输出混在一起时，我们还可以用grep工具将特定id的goroutine的函数跟踪输出过滤出来，比如：functrace-demo|grep "01"）。

5. 利用代码生成将trace代码注入到各个函数中

在前面我们提到过上面实现的一个问题，那就是一旦将trace写死到各个函数代码中，即便在trace开关未打开的情况下，依然是有性能损耗的。并且，上面的实现存在着对业务代码的较强的“代码侵入性”。那么我们能否减少侵入，像分布式服务跟踪那样将“跟踪”的设施注入(instrumenting)到需要跟踪的函数中呢？下面我们就来尝试一下。

1) 将trace单独打包为一个module

我们首先要做的就是将trace相关的代码单独提取打包为一个module。这里我将上面的trace.go和trace_nop.go放入了一个路径为github.com/bigwhite/functrace的module中：

$tree -F -L 2 functrace 
functrace
├── LICENSE
... ...
├── README.md
├── example_test.go
├── go.mod
├── go.sum
├── trace.go
└── trace_nop.go

有了这个module，你可以以“侵入式”的方式为你的代码添加函数链调用跟踪，就像上面repo中example_test.go中的那样：

// https://github.com/bigwhite/functrace/blob/main/example_test.go
import (
 "github.com/bigwhite/functrace"
)

func a() {
 defer functrace.Trace()()
 b()
}

func b() {
 defer functrace.Trace()()
 c()
}

func c() {
 defer functrace.Trace()()
 d()
}

func d() {
 defer functrace.Trace()()
}

func ExampleTrace() {
 a()
 // Output:
 // g[01]: ->github.com/bigwhite/functrace_test.a
 // g[01]:  ->github.com/bigwhite/functrace_test.b
 // g[01]:   ->github.com/bigwhite/functrace_test.c
 // g[01]:    ->github.com/bigwhite/functrace_test.d
 // g[01]:    <-github.com/bigwhite/functrace_test.d
 // g[01]:   <-github.com/bigwhite/functrace_test.c
 // g[01]:  <-github.com/bigwhite/functrace_test.b
 // g[01]: <-github.com/bigwhite/functrace_test.a
}
2) 增加代码注入功能

我们在github.com/bigwhite/functrace仓库中增加了一个名为gen的工具。利用该工具我们可以将functrace中的trace基础设施代码自动注入(instrumenting)到目标源文件的各个函数定义中。这个工具调用的核心算法在github.com/bigwhite/functrace/pkg/generator中：

// github.com/bigwhite/functrace/blob/main/pkg/generator/rewrite.go
func Rewrite(filename string) ([]byte, error) {
        fset := token.NewFileSet()
        oldAST, err := parser.ParseFile(fset, filename, nil, 0)
        if err != nil {
                return nil, fmt.Errorf("error parsing %s: %w", filename, err)
        }

        if !hasFuncDecl(oldAST) {
                return nil, nil
        }

        // add import declaration
        astutil.AddImport(fset, oldAST, "github.com/bigwhite/functrace")

        // inject code into each function declaration
        addDeferTraceIntoFuncDecls(oldAST)

        buf := &bytes.Buffer{}
        err = format.Node(buf, fset, oldAST)
        if err != nil {
                return nil, fmt.Errorf("error formatting new code: %w", err)
        }
        return buf.Bytes(), nil
}

我们看到这个包的Rewrite函数使用了Go项目提供的go/ast包以及Go扩展项目提供的ast(抽象语法树)操作工具包golang.org/x/tools/go/ast/astutil对目标源文件进行解析、修改并重建的。go/ast包的内容较多，其本身就具备单独写几篇文章了，这里不赘述。有兴趣的童鞋可以移步本文后面的参考资料，或查看go官方文档了解。

为了帮助大家了解如何使用gen生成带有trace的代码，我还在functrace这个repo中建立了一个demo：examples/gen-demo：

$tree examples/gen-demo 
examples/gen-demo
├── Makefile
├── go.mod
├── go.sum
└── main.go

在该demo中，我们利用go generate生成带有跟踪代码的目标代码：

// https://github.com/bigwhite/functrace/blob/main/examples/gen-demo/main.go
package main

//go:generate ../../gen -w main.go

... ...

构建该demo并运行(为了方便构建，我建立了Makefile)：


// Makefile
all:
 go generate
 go build -tags trace

$make
go generate
[../../gen -w main.go]
add trace for main.go ok
go build -tags trace

$./functrace-demo 
g[01]: ->main.main
g[01]:  ->main.A2
g[01]:   ->main.B2
g[01]:    ->main.C2
g[01]:     ->main.D
g[01]:     <-main.D
g[01]:    <-main.C2
g[01]:   <-main.B2
g[01]:  <-main.A2
g[18]: ->main.A1
g[18]:  ->main.B1
g[18]:   ->main.C1
g[18]:    ->main.D
g[18]:    <-main.D
g[18]:   <-main.C1
g[18]:  <-main.B1
g[18]: <-main.A1
g[01]: <-main.main

我们看到，我们通过ast将跟踪代码注入到目标代码并运行的思路成功实现了！

6. 小结

functrace module中Trace函数的实现比较简单，目前仅是输出日志，但实际上我们可以在Trace函数中以及Trace函数返回的匿名函数中通过各种方式输出我们想要的数据，比如，像分布式服务跟踪那样，将数据发送到一个集中的后端做统一存储、分析和展示。但鉴于篇幅和需求不同，这里仅给出满足演示的实现，大家可以自行fork该repo以实现满足你们自己需求的实现。

7. 参考资料

  • https://mattermost.com/blog/instrumenting-go-code-via-ast/

  • https://developers.mattermost.com/blog/open-tracing/

  • https://blog.gopheracademy.com/code-generation-from-the-ast/

  • http://www.go2live.cn/nocate/golang-ast语法树使用教程及示例.html

  • https://www.ctolib.com/topics-80234.html

  • https://github.com/yuroyoro/goast-viewer

  • https://liudanking.com/performance/golang-%e8%8e%b7%e5%8f%96-goroutine-id-%e5%ae%8c%e5%85%a8%e6%8c%87%e5%8d%97/

本文中涉及到的示例源码可以到这里下载 https://github.com/bigwhite/experiments/tree/master/trace-function-call-chain。

“Gopher部落”知识星球开球了！高品质首发Go技术文章，“三天”首发阅读权，每年两期Go语言发展现状分析，每天提前1小时阅读到新鲜的Gopher日报，网课、技术专栏、图书内容前瞻，六小时内必答保证等满足你关于Go语言生态的所有需求！星球首开，福利自然是少不了的！2020年年底之前，8.8折(很吉利吧^_^)加入星球，下方图片扫起来吧！

我的Go技术专栏：“改善Go语⾔编程质量的50个有效实践”上线了，欢迎大家订阅学习！


我的网课“Kubernetes实战：高可用集群搭建、配置、运维与应用”在慕课网热卖中，欢迎小伙伴们订阅学习！


我爱发短信：企业级短信平台定制开发专家 https://51smspush.com/ smspush : 可部署在企业内部的定制化短信平台，三网覆盖，不惧大并发接入，可定制扩展；短信内容你来定，不再受约束, 接口丰富，支持长短信，签名可选。

2020年4月8日，中国三大电信运营商联合发布《5G消息白皮书》，51短信平台也会全新升级到“51商用消息平台”，全面支持5G RCS消息。

著名云主机服务厂商DigitalOcean发布最新的主机计划，入门级Droplet配置升级为：1 core CPU、1G内存、25G高速SSD，价格5$/月。有使用DigitalOcean需求的朋友，可以打开这个链接地址：https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻)归档仓库 - https://github.com/bigwhite/gopherdaily

我的联系方式：

  • 微博：https://weibo.com/bigwhite20xx

  • 微信公众号：iamtonybai

  • 博客：tonybai.com

  • github: https://github.com/bigwhite

  • “Gopher部落”知识星球：https://public.zsxq.com/groups/51284458844544

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

Tony Bai
关注
大规模分布式系统跟踪基础设施Dapper
热门推荐
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
03-17 5万+
论文《Dapper, a Large-Scale Distributed Systems Tracing Infrastructure》介绍了谷歌开发的大规模分布式系统跟踪基础设施Dapper。Dapper旨在通过提供跨多个服务和计算机的详细跟踪信息，帮助开发人员理解和调试复杂的分布式系统。论文讨论了Dapper背后的动机、其架构以及在诊断性能问题和优化分布式系统方面所提供的实际好处。本文作为回顾经典，重新学习，翻译的同时加入一些现有的理解。
SQL调用远程服务器的函数
最新发布
零零发不爱ai的博客
08-06 543
在SQL中调用远程服务器的函数通常不是一个直接支持的操作，因为SQL本身是一种查询和操作数据库的标准语言，它并不直接支持跨数据库服务器的函数调用。然而，你可以通过几种方式来实现类似的功能，这取决于你使用的数据库系统（如MySQL, PostgreSQL, SQL Server等）以及你的具体需求。
像跟踪分布式服务调用那样跟踪Go函数调用链 | Gopher Daily (2020.12.07) ʕ◔ϖ◔ʔ
TonyBai
12-07 500
每日一谚：“A cache is just a memory leak you haven’t met yet.” — Mr. RogersGo技术专栏“改善Go语⾔编程质量的50个有效...
go源码分析(五) 获取函数名和调用者的函数名
diruanqi7788的博客
12-25 234
参考资料 实现代码保存在我的github // input flag 1:FunName 2:CallerFunName func GetFuncName(flag int) string { if flag != 1 && flag != 2 { flag = 1 } pc, _, _, _ := Caller(...
⚡️ go-instrument：自动为Go方法和函数添加Trace Span
gitblog_00017的博客
06-12 399
⚡️ go-instrument：自动为Go方法和函数添加Trace Span 项目介绍 go-instrument 是一个强大的开源工具，旨在自动为Go语言中的方法和函数添加Trace Span。通过使用标准的Go库来修改AST（抽象语法树），go-instrument 能够无缝地为你的代码注入跟踪信息，从而简化分布式跟踪的实现过程。无需手动编写繁琐的跟踪代码，go-instrument 能够自...
Go函数（二）之defer实现代码追踪
Chasel_H
12-09 213
本文仅是自己阅读笔记，不正确之处请多包涵和纠正。 原文The way to go 关键字 defer 允许我们推迟到函数返回之前一刻或任意位置执行 return 语句之后才执行某个语句或函数。 为什么要在返回之后才执行这些语句？ 因为 return 语句同样可以包含一些操作，而不是单纯地返回某个值 package main import "fmt" func main() { function1() } func function1() { fmt.Printf("In function1 at t
go中函数的调用机制
实践求真知
04-11 288
一图解函数调用 程序员调用方法：给方法必要的输入，方法返回结果。 二 函数调用过程实战 1 传入一个数+1 说明 a 在调用一个函数时，会给该函数分配一个新的空间，编译器会通过自身的处理让这个新的空间和其它的栈的空间区分开来。 b 在每个函数对应的栈中，数据空间是独立的，不会混淆。 c 当一个函数调用完毕后，程序会销毁这个函数对应的栈空间。 2 计算两个数，并返回结果 代码 package main import ( "fmt" ) // 一个函数 getSum f.
Dubbo分布式服务调用示例解析
其中，“RPC” 是 Dubbo 的核心技术基础，它允许不同进程间的程序像调用本地函数一样调用对方的方法，极大地简化了分布式系统的开发难度。“分布式服务”则指明了应用场景：当系统规模扩大，单体架构无法满足性能和...
【SpringCloud微服务笔记04】分布式中的服务调用
qq_53462109的博客
04-03 949
我们先来看一下什么是远程调用，所谓的远程调用，我们可以用简单的图例进行说明：不管是微服务还是分布式服务，都有服务提供者和消费者两端，而两者之间是如何实现相互调用的，就是我们要研究的远程调用技术。两种。
surging 是一个分布式微服务框架,提供高性能RPC远程服务调用，采用Zookeeper
05-31
Surging 是一款强大的分布式微服务框架，其核心特性在于提供了高性能的RPC（Remote Procedure Call）远程服务调用机制。在微服务架构中，服务间的通信是至关重要的，Surging 正是为了解决这一问题而设计。通过使用 ...
Go-Gocyto-Go的调用图(Callgraph)分析和可视化
08-14
Gocyto- Go的调用图(Callgraph)分析和可视化
strace跟踪go读取文件函数
yangzhengqui的专栏
07-02 779
strace 是跟踪系统调用的工具，通过跟踪代码发现go语言的read函数是通过汇编函数实现的，所以用strace没有发现有系统调用。。。。
golang tcp listen(函数调用链)
人与人的差距，最小的是智商，最大的是坚毅。
06-12 4407
golang thrift 调用listen函数调用过程； 1.golang的业务程序使用thrift框架进行通信； 2.当业务程序调用thrfit的Serve函数(simple_server.go)时，会调用listen函数； Listen函数会调用server_socket.go中的TServerSocket的Listen函数， TServerSocket的Listen函数，会
go 链路追踪_调用链 OpenTracing + Jaeger + 阿里云链路追踪
weixin_39717825的博客
12-12 1096
OpenTracing从分布式系统架构普及之后，各个公司+社区出了很多监控调用链的项目，因为标准都不相同，最后 OpenTracing 这种规范一统天下。https://github.com/opentracing 安装opentracing的python包，pip install opentracing, 可以看到源码，里面统一定义了概念和流程，并且有一些接口需要被具体实现才能用。 核心原理是...
Golang链路追踪：实现高效可靠的分布式系统监控
hitpter的专栏
10-25 983
链路追踪是一种用于监控分布式系统中请求的传输路径和性能的技术。它能够帮助开发人员和运维人员快速定位和排查系统中的性能问题和错误。链路追踪记录了请求从发起方到目标方的完整路径，并在每个节点上记录请求的处理时间、调用的服务和调用的方法等信息。在一个典型的分布式系统中，一个请求可能要经过多个服务的处理。每个服务都会记录请求的一些重要信息，并将这些信息传递给下一个服务。通过链路追踪，我们可以从整体上了解请求的处理流程，找出潜在的性能瓶颈和错误。
dubbo - 分布式调用
weixin_45453240的博客
09-27 741
概述 分布式系统：分布式系统是若干独立单个相关系统的集合，是建立在网络之上的软件系统，随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，亟需一个治理系统确保架构有条不紊的演进。 单一应用架构：当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增删改查工作量的数据访问框架(ORM)是关键 优点：适用于小型网站，小型管理系统，将所有功能都部署到一个功能里，简单易用。 缺点：性能扩展比较难，协同开发问题，不
分布式计算——远程对象和远程方法的调用
Bob的博客
04-04 3237
分布式计算中有个远程方法的调用，在此基础上有个作业是在调用的远程方法中传递两个参数， 一个参数是本地对象，一个参数是远程对象。 下面就对这次的作业结果进行整理。 作业的要求如下：Java RMI远程方法调用实验：若一个方法是远程调用，其参数一是本地对象、参数二是远程对象，请实现程序， 在三台计算机上执行该程序，观察实验现象，报告实验结果。 作业要求图： ============
Go 获取函数调用链
简单随风的博客
06-11 2671
利用工具函数golang.org/x/tools获取函数调用链
如何在Go的函数中得到调用者函数名?
weixin_33861800的博客
11-06 1563
有时候在Go的函数调用的过程中，我们需要知道函数被谁调用，比如打印日志信息等。例如下面的函数，我们希望在日志中打印出调用者的名字。 1func Foo() { 2 fmt.Println("谁在调用我？") 3 bar() 4} 5func Bar() { 6 fmt.Println("谁又在调用我？") 7} 首先打印函数...
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值