go生命周期-从源码角度

已于 2024-04-24 20:49:56 修改
阅读量1.2k 收藏 1
点赞数
分类专栏： goland开发 文章标签： golang
于 2022-12-30 10:34:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012728971/article/details/128491918
版权

好奇心

出于好奇，想了解go的执行生命周期，于是尝试跟着go的源码看看执行过程

go源码地址：GitHub - golang/go: The Go programming language

1.根据命令行编译文件，然后执行二进制文件

（1）从go运行命令开始：#go run main.go

（2）入口在源码文件：//src/cmd/go/main.go  ，找main()函数

// init() 函数，是go的隐式调用的，即会在包引入就执行。这里会在main()运行前初始化一些go的基本命令 
fun init(){
  base.Go.Commands = []*base.Command{ //go基本命令定义
    ...
    work.CmdBuild,
    run.CmdRun, //go run 命令定义
    ...
  }
}


fun main(){
    _ = go11tag  //
   flag.Usage = base.Usage
   flag.Parse() //从os.Args[1:]解析输入的命令行参数，从切片1开始
   log.SetFlags(0)
   args := flag.Args()//args[0]就是go后面跟的参数，我们这里是run
   if len(args) < 1 {
      base.Usage()
   }
   //如果是get或help的命令，
   if args[0] == "get" || args[0] == "help" {
      if !modload.WillBeEnabled() {
         // Replace module-aware get with GOPATH get if appropriate.
         *modget.CmdGet = *get.CmdGet
      }
   }
   cfg.CmdName = args[0] // for error messages
   //如果是get或help的命令，
   if args[0] == "help" {
      help.Help(os.Stdout, args[1:])
      return
   }
   //检查GOPATH的设置是否正确，不正确就退出了
   ...
   
//核心是BigCmdLoop这段循环执行命令
BigCmdLoop:
   for bigCmd := base.Go; ; {//go 基本命令结构体
      for _, cmd := range bigCmd.Commands {//go 可用命令列表
         //前面我们知道args[0]=run,args[1]=main.go
         if cmd.Name() != args[0] { //如果命令匹配不上就执行下一个
            continue
         }
         //如果有类似go mod help foo 更多的命令
         if len(cmd.Commands) > 0 {
            bigCmd = cmd
            args = args[1:] //把子命令截取，如：args[0]=help
            if len(args) == 0 {
               help.PrintUsage(os.Stderr, bigCmd)
               base.SetExitStatus(2)
               base.Exit()
            }
            if args[0] == "help" {
               // Accept 'go mod help' and 'go mod help foo' for 'go help mod' and 'go help mod foo'.
               help.Help(os.Stdout, append(strings.Split(cfg.CmdName, " "), args[1:]...))
               return
            }
            //错误提示信息"build", "install", "list", "mod tidy", etc.
            cfg.CmdName += " " + args[0]
            continue BigCmdLoop
         }
         if !cmd.Runnable() {
            continue
         }
         //把命令参数传过去，调用具体方法
         invoke(cmd, args)
         base.Exit()
         return
      }
      helpArg := ""
      if i := strings.LastIndex(cfg.CmdName, " "); i >= 0 {
         helpArg = " " + cfg.CmdName[:i]
      }
      fmt.Fprintf(os.Stderr, "go %s: unknown command\nRun 'go help%s' for usage.\n", cfg.CmdName, helpArg)
      base.SetExitStatus(2)
      base.Exit()
   }
}


func invoke(cmd *base.Command, args []string) {
  ...
  //如go run main.go这个执行会真正执行到对应的实现函数去
  cmd.Run(ctx, cmd, args)//CmdRun.Run = runRun,实际上会调runRun方法(go build，CmdBuild.Run = runBuild)
  span.Done()
}
invoke()方法会真正执行到src/cmd/go/internal/run/run.go里面的runRun()方法（如果是go build main.go会找到src/cmd/go/internal/work/build.go的runBuild)

（3）源码文件：//src/cmd/go/internal/run/run.go  ，找runRun()方法

var CmdRun = &base.Command{
  UsageLine: "go run [build flags] [-exec xprog] package [arguments...]",
  Short:     "compile and run Go program",
  Long: `Run compiles and runs the named main Go package...`,//Run编译并运行命名的主Go包...
}
func init() {
   
   CmdRun.Run = runRun // break init loop
   work.AddBuildFlags(CmdRun, work.DefaultBuildFlags)
   CmdRun.Flag.Var((*base.StringsFlag)(&work.ExecCmd), "exec", "")
}
//go run main.go最终会执行到这里
func runRun(ctx context.Context, cmd *base.Command, args []string) {
  //看run时有没有指定包，如go run cmd@version，有则导入包
  if shouldUseOutsideModuleMode(args) {
     // Set global module flags for 'go run cmd@version'.
     // This must be done before modload.Init, but we need to call work.BuildInit
     // before loading packages, since it affects package locations, e.g.,
     // for -race and -msan.
     modload.ForceUseModules = true
     modload.RootMode = modload.NoRoot
     modload.AllowMissingModuleImports()
     modload.Init()
  }
  //运行之前，先编译，根据机器将源码编译成对应可执行文件，大概过程
  //1.词法分析（编译器会将扫描到的词法单位（Lexemes）归类到常量、保留字、运算符等标记（Tokens）中）
  //2.语法分析（接收上一阶段生成的Tokens序列，基于特定编程语言的规则生成抽象语法树AST）
  //3.语义分析(语义分析阶段用来检查代码的语义一致性)
  //4.中间码生成(中间代码介是于高级语言和机器语言之间，具有跨平台特性)
  //5.代码优化(改进中间代码，删除不必要的代码)
  //6.机器码生成（基于中间码生成汇编代码,汇编器根据汇编代码生成目标文件，目标文件经过链接器处理最终生成可执行文件）
  //基本所有的高级语言到机器码的输出都需要编译这个过程
  work.BuildInit()
  var b work.Builder
  //初始化
  b.Init()
  ...
  //链接到可执行文件
  a1 := b.LinkAction(work.ModeBuild, work.ModeBuild, p)
  //执行，buildRunProgram：是执行二进制文件
  a := &work.Action{Mode: "go run", Func: buildRunProgram, Args: cmdArgs, Deps: []*work.Action{a1}}
  b.Do(ctx, a)
}
 可以看的run之前，是先进行打包的：work.BuildInit()，打包完就是进行链接执行了。

（4）打包work.BuildInit()

         (4-1)词法分析：编译器会将扫描到的词法单位（Lexemes）归类到常量、保留字、运算符等标记（Tokens）中

         (4-2)语法分析：接收上一阶段生成的Tokens序列，基于特定编程语言的规则生成抽象语法树AST

         (4-3)语义分析：语义分析阶段用来检查代码的语义一致性

         (4-4)中间码生成：中间代码介是于高级语言和机器语言之间，具有跨平台特性

         (4-5)代码优化：改进中间代码，删除不必要的代码)

         (4-6)机器码生成：基于中间码生成汇编代码,汇编器根据汇编代码生成目标文件，目标文件经过链接器处理最终生成可执行文件

（5）链接到可执行文件

     a1 := b.LinkAction(work.ModeBuild, work.ModeBuild, p)

（6）执行二进制文件

          buildRunProgram：是执行二进制文件

     a := &work.Action{Mode: "go run", Func: buildRunProgram, Args: cmdArgs, Deps: []*work.Action{a1}}

 到这里才开始执行二进制文件，才真正跑起main这个二进制文件。类似我们在服务器上启动：./main

（7）小结图解

2.引导程序执行，程序执行真正入口

（1）引导程序入口

go引导阶段，真正的程序入口在 src/runtime 包中，不同的计算机架构指向不同.如arm64的linux,对应的机器码就会找对应的入口

//src/runtime/rt0_linux_amd64.s

看名字很直观:

rt0：表示runtime0,

liunx:表示操作系统，

amd64:支持AMD64指令集，指处理器架构

平时我们打包程序：gf build main.go -n main -a amd64 -s linux -p  ，生成的机器码就是对应amd64指令集的。当我们执行时，操作系统就会引导程序来

（2）引导程序开始引导执行

   （2-1）src/runtime/rt0_linux_amd64.s 这里的入口开始执行。

#include "textflag.h"
TEXT _rt0_amd64_linux(SB),NOSPLIT,$-8
   JMP    _rt0_amd64(SB)
TEXT _rt0_amd64_linux_lib(SB),NOSPLIT,$0
   JMP    _rt0_amd64_lib(SB)
_rt0_amd64(SB)会找到//src/runtime/asm_amd64.s的TEXT _rt0_amd64(SB),NOSPLIT,$-8 方法

  （2-2）//src/runtime/asm_amd64.s ，引导执行的核心方法

TEXT _rt0_amd64(SB),NOSPLIT,$-8
   MOVQ   0(SP), DI  // argc
   LEAQ   8(SP), SI  // argv
   JMP    runtime·rt0_go(SB)
   
...
TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
   // copy arguments forward on an even stack
   MOVQ   DI, AX    // argc
   MOVQ   SI, BX    // argv
   SUBQ   $(5*8), SP    // 3args 2auto
   ANDQ   $~15, SP
   MOVQ   AX, 24(SP)
   MOVQ   BX, 32(SP)
   // create istack out of the given (operating system) stack.
   // _cgo_init may update stackguard.
   //创建最初的G g0
   MOVQ   $runtime·g0(SB), DI
   LEAQ   (-64*1024+104)(SP), BX
   MOVQ   BX, g_stackguard0(DI)
   MOVQ   BX, g_stackguard1(DI)
   MOVQ   BX, (g_stack+stack_lo)(DI)
   MOVQ   SP, (g_stack+stack_hi)(DI)
  // find out information about the processor we're on
  MOVL   $0, AX
  CPUID
  CMPL   AX, $0
  JE nocpuinfo   
...
  
ok:
   // set the per-goroutine and per-mach "registers"
   //创建最初的线程 m0 和 goroutine g0，并把两者进行关联（g0.m = m0)
   get_tls(BX) //本地线程存储 （Thread Local Storage, TLS）
   LEAQ   runtime·g0(SB), CX
   MOVQ   CX, g(BX)
   LEAQ   runtime·m0(SB), AX
   // save m->g0 = g0
   MOVQ   CX, m_g0(AX)
   // save m0 to g0->m
   MOVQ   AX, g_m(CX)
  ...
  CALL    runtime·args(SB)//系统参数传递，主要是将系统参数转换传递给程序使用
  CALL   runtime·osinit(SB)//系统基本参数设置，主要是获取 CPU 核心数和内存物理页大小
  //各种运行时组件初始化工作.如调度器、内存分配器、堆、栈、GC 等。
  CALL   runtime·schedinit(SB)
  // create a new goroutine to start program
  //创建一个新的goroutine来启动程序，main()函数入口
  MOVQ   $runtime·mainPC(SB), AX       // entry
  PUSHQ  AX
  //创建一个运行fn的新goroutine。(GMP中的G)
  //把它放在等待运行的g队列中（goroutine调度队列，GMP中的p）
  //编译器将go语句转换为对this的调用。
  //会进行 p 的初始化，并将 m0 和某一个 p 进行绑定
  CALL   runtime·newproc(SB)
  POPQ   AX
  // start this M ,开启一个内核线程(GMP中的M)，调用mstart0,调mstart1，调度器开始进行循环调度
  CALL   runtime·mstart(SB)
  CALL   runtime·abort(SB)  // mstart should never return

 

（2-3）m0和g0创建
 

   get_tls(BX)  //本地线程存储 （Thread Local Storage, TLS）
   LEAQ   runtime·g0(SB), CX
   MOVQ   CX, g(BX)
   LEAQ   runtime·m0(SB), AX
   // save m->g0 = g0
   MOVQ   CX, m_g0(AX)
   // save m0 to g0->m
 

     创建最初的线程 m0 和 goroutine g0，并把两者进行关联（g0.m = m0)， g0 和 m0 是一组全局变量。
 

     m0 : m0 是 Go 启动时所创建的第一个系统线程，一个 Go 进程只有一个 m0，也叫主线程。
 

     g0：是m结构上的g指针，负责普通G在M上的调度切换。每个M都有自己的g0，即m0->g0,m1->g0...
 

type m struct {
   g0      *g // goroutine with scheduling stack
     ...

}
 

type g struct {
 stack       stack // offset known to runtime/cgo
 ...
 m         *m // current m; offset known to arm liblink
 sched     gobuf
...

}
 

   （2-4） 关于GMP:
 

     G-Goroutine:Go协程，是参与调度与执行的最小单位。普通G是执行用户任务的协程G。g0比较特殊，是执行调度普通G执行任务的。
 

     M-Machine:系统内核级别线程,m0是主线程，一个 Go 进程只有一个 m0，后续M由 Go Runtime 内自行创建。主线程m0在启动完初始化工作之后，会和普通M工作一样。
 

     P-Processor:是逻辑处理器，P关联了的本地可运行G的队列(也称为LRQ)，最多可存放256个G
 

（2-5）g0，常规g,m0,常规M
 

m0和普通m:
 

      m0是主线程，一个 Go 进程只有一个 m0，后续M由 Go Runtime 内自行创建。主线程m0在启动完初始化工作之后，会和普通M工作一样。
 

g0和普通g:
 

g0 比较特殊，每一个 m 都只有一个 g0(仅此只有一个 g0)，且每个 m 都只会绑定一个 g0。
 

A.数据结构一样
 

B.存在栈不同：g0栈分配的是系统栈,linux上栈默认大小是固定8M,不能扩缩。常规g起始只有2KB,可扩缩
 

C.运行状态不同：g0没那么多运行状态，也不会被调度程序抢占，调度本身就是在g0上运行的
 

(3) CALL runtime·schedinit(SB)各种运行时组件初始化工作
 

  （3-1）src/runtime/proc.go,启动核心的方法。初始化如调度器、内存分配器、堆、栈、GC 等
 

func schedinit() {
  ...
  sched.maxmcount = 10000 //初始化机器线程数M最大为10000
  ...
  stackinit()//goroutine 执行栈初始化
  mallocinit()//内存分配器初始化
  initPageTrace(godebug)//内存页初始化
  ...
  modulesinit()   // 系统线程的部分初始化工作
  ...
  gcinit()//垃圾回收初始化
  ...
  procs := ncpu //P(go逻辑处理器)数量，gogetenv("GOMAXPROCS")
  procs := ncpu
  //GOMAXPROCS的数量一般和cup的核数相同，因为M和P是一一绑定的
  if n, ok := atoi32(gogetenv("GOMAXPROCS")); ok && n > 0 {
   procs = n
  }
  ...
  procresize(procs)
  ...
}
 

(4) CALLruntime·newproc(SB)会进行 p 的初始化，并将 m0 和某一个 p 进行绑定
 

  （4-1）src/runtime/proc.go,这里GMP中的三个关键结构就出现了
 

//创建一个运行fn的新goroutine。
func newproc(fn *funcval) {
   gp := getg()
   pc := getcallerpc()
   systemstack(func() {
      newg := newproc1(fn, gp, pc)
      pp := getg().m.p.ptr()
      runqput(pp, newg, true)
      if mainStarted {
         wakep()
      }
   })
}
 

(5) CALL runtime·mstart(SB)启动循环调度
 

  （5-1）src/runtime/proc.go,这里start this M ,开启一个内核线程(GMP中的M)，调用mstart0,调mstart1，调度器开始进行循环调度
 

// mstart is the entry-point for new Ms.
// It is written in assembly, uses ABI0, is marked TOPFRAME, and calls mstart0.
func mstart()
//创建一个运行fn的新goroutine。
func mstart0() {
   gp := getg()
   osStack := gp.stack.lo == 0
   if osStack {
      // Initialize stack bounds from system stack.
      // Cgo may have left stack size in stack.hi.
      // minit may update the stack bounds.
      //
      // Note: these bounds may not be very accurate.
      // We set hi to &size, but there are things above
      // it. The 1024 is supposed to compensate this,
      // but is somewhat arbitrary.
      size := gp.stack.hi
      if size == 0 {
         size = 8192 * sys.StackGuardMultiplier
      }
      gp.stack.hi = uintptr(noescape(unsafe.Pointer(&size)))
      gp.stack.lo = gp.stack.hi - size + 1024
   }
   // Initialize stack guard so that we can start calling regular
   // Go code.
   gp.stackguard0 = gp.stack.lo + _StackGuard
   // This is the g0, so we can also call go:systemstack
   // functions, which check stackguard1.
   gp.stackguard1 = gp.stackguard0
   mstart1()
   // Exit this thread.
   if mStackIsSystemAllocated() {
      // Windows, Solaris, illumos, Darwin, AIX and Plan 9 always system-allocate
      // the stack, but put it in gp.stack before mstart,
      // so the logic above hasn't set osStack yet.
      osStack = true
   }
   //退出线程
   mexit(osStack)
}
//保存g0的调度信息
// The go:noinline is to guarantee the getcallerpc/getcallersp below are safe,
// so that we can set up g0.sched to return to the call of mstart1 above.
func mstart1() {
  ...
  schedule()
}
//调度器:找到一个可运行的goroutine并执行它。
func schedule() {
  ...
  execute(gp, inheritTime)
}
//调度gp在当前M上运行。
func execute(gp *g, inheritTime bool) {
  ...
}
 

（6）小结图解
 

 

 

到这里初步了解go执行过程，后续还有很多个点需要再细致了解，中间参考了很多优秀的文章。
 

参考资料：
 

知乎：mingguangtu的深入分析Go1.18 GMP调度器底层原理：深入分析Go1.18 GMP调度器底层原理 - 知乎
 

欧长坤创作的go语言原本 ：Changkun Ou | Go 语言原本
 

tink.的GMP模型：https://go.cyub.vip/gmp/gmp-model.html#id11

                

        

        

    

  


    

      

        

            

              
                
                  小鱼不会游泳
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
Go: 协程的生命周期管理

				
			

			

				

					手写我对你的温柔
				

				

					06-02
					
					2085
					
				

			

		

		

			
				
协程的生命周期：

1. 定义：

协程的创建等全部生命历程的管理。通俗的讲就是“保姆”。

它的作用是便于协程的回收利用。


goroutine申请的代价很小，但是在go程序中，goroutine的总量是有上限，超过上限，多余出来的协程就得等到前面的协程完成任务后能开始运行。所以适时的进行回收。


2. 生命周期分类：

协程创建
	协程回收： 由Go语言的GC和垃圾回收机制控制的
	协程中断： 通过context包实现
3. 如何实现：

context实现中断



package main

.

			
		

	



                

              
                



	

		

			

				
					
从源码角度详解Golang调度GMP

				
			

			

				

					yonggeit的博客
				

				

					07-23
					
					285
					
				

			

		

		

			
				
前面都是各种初始化操作，在这里开启了调度器的第一个调度循环。(这里启动的 M 就是 M0)下面来围绕 G、M、P 三个概念介绍 Goroutine 调度循环的运作流程。

			
		

	



                


  
              

                


	

		

			

				
					
Go语言变量的生命周期

				
			

			

				

					xyz的专栏
				

				

					09-04
					
					437
					
				

			

		

		

			
				
在讨论变量生命周期之前，先来了解下计算机组成里两个非常重要的概念：堆和栈。变量的生命周期我们将在下一节《变量生命周期》中为大家讲解。

什么是栈

栈（Stack）是一种拥有特殊规则的线性表数据结构。

1) 概念

栈只允许从线性表的同一端放入和取出数据，按照后进先出（LIFO，Last InFirst Out）的顺序，如下图所示。





图：栈的操作及扩展


往栈中放入元素的过程叫做入栈。入栈会增加栈的元素数量，最后放入的元素总是位于栈的顶部，最先放入的元素总是位于栈的底部。
从栈中取出元素...

			
		

	





	

		

			

				
					
Go中变量的生命周期

					
最新发布

				
			

			

				

					ecloud_developer的博客
				

				

					07-26
					
					430
					
				

			

		

		

			
				
生命周期指变量在程序执行过程中存在的时间段。包级别变量的生命周期是整个程序的执行时间。相反，局部变量有一个动态的生命周期：每次执行声明语句时创建一个新的实体，变量一直生存到它变得不可访问，此时它占用的存储空间被回收。函数的参数和返回值也是局部变量，它们在其闭包函数被调用的时候创建。在如上代码片段中，变量t在每次for循环的开始创建，变量x和y在循环的每次迭代中创建。那么垃圾回收器如何知道一个变量是否应该被回收？

			
		

	



		

			
		



	

		

			

				
					
Go语言变量的生命周期与作用域

				
			

			

				

					SteveRocket's-Blog
				

				

					10-18
					
					417
					
				

			

		

		

			
				
通过本篇文章，我们已经看到包、文件、声明和语句如何来表达一个程序结构。我们也了解了变量的作用域可以帮助我们编写更清晰、易于维护的代码。合理使用作用域可以避免变量名冲突和不必要的全局变量，提高代码的可读性和可维护性。
最后我们来总结下变量在代码中的作用域：

    全局作用域的变量可以在整个程序中访问。
    函数作用域的变量只能在函数内部访问。
    块作用域的变量只能在代码块内部访问。
    作用域可以嵌套，内部作用域可以访问外部作用域的变量。
    同名变量在不同的作用域中是相互独立的

			
		

	





	

		

			

				
					
Go实现控制任程序的生命周期

				
			

			

				

					happyAnger6的专栏
				

				

					04-23
					
					1275
					
				

			

		

		

			
				
runner/runner.go:
package runner

import (
	"errors"
	"os"
	"os/signal"
	"time"
)

type Runner struct {
	interrupt chan os.Signal

	complete chan error

	timeout <-chan time.Time

	tasks []func(int)

			
		

	





	

		

			

				
					
对Go中变量的生命周期理解

				
			

			

				

					zp17834994071的博客
				

				

					09-30
					
					479
					
				

			

		

		

			
				
生命周期很好理解，就是正常能使用的变量的有效时间，超过时间限定后，变量就无法再生效，必须重新创建新的变量。变量的生命周期一般指的是在程序运行期间变量有效存在的时间间隔。
对于在包一级声明的变量来说，它们的生命周期和整个程序的运行周期是一致的。而相比之下，局部变量的声明周期则是动态的：每次从创建一个新变量的声明语句开始，直到该变量不再被引用为止，然后变量的存储空间可能被回收。函数的参数变量和返回值变量都是局部变量。它们在函数每次被调用的时候创建。
变量的生命周期与变量的作用域有着不可分割的联系：

全局变量：

			
		

	





	

		

			

				
					
golang源码分析--gc

				
			

			

				

					hello_bravo_的博客
				

				

					12-31
					
					794
					
				

			

		

		

			
				
golang的垃圾回收采用的是 标记-清理（Mark-and-Sweep） 算法
就是先标记出需要回收的内存对象快，然后在清理掉；
根据源码注释GC的流程如下:
gcphase的三个状态
_GCoff   // GC not running; sweeping in background, write barrier disabled
_GCmark  // GC marking roots an...

			
		

	





	

		

			

				
					
Activity 生命周期函数执行过程详解

				
			

			

				

					AdobeSolo的博客
				

				

					12-03
					
					1729
					
				

			

		

		

			
				
平时开发中接触到Android的启动以及各种生命周期函数，但是其背后的执行过程是怎么样的呢？本文从源码的角度来分析activity的启动以及它的生命周期函数。 
关键的类在分析源码之前，先了解下几个关键的类的作用：ActivityManagerService：activity的启动以及生命周期都统一由ActivityManagerService管理，而ActivityManagerService处于

			
		

	





	

		

			

				
					
以太坊之node生命周期详解

				
			

			

				

					u010110632的专栏
				

				

					02-05
					
					888
					
				

			

		

		

			
				
代码：github.com/ethereum/go-ethereum
版本：96157a897be2032be5fdb87f947fbe5df8a53bd4
一、官方介绍
node包实现了一个可以包含多种协议的以太坊节点。
节点是服务得集合，这些服务使用共享资源提供的RPC API。服务还可以提供Devp2p协议，当启动节点实例时，这些协议会连接到Devp2p网络。
1、节点生命周期
节点对象得生命周期分为三个状态，INITIALIZING，RUNNING，CLOSED。状态流转如下：
●───────┐


			
		

	





	

		

			

				
					
2022-10-24 ClickHouse 源码解析-查询引擎经典理论

				
			

			

				

					技术之路
				

				

					10-24
					
					1423
					
				

			

		

		

			
				
向量化执行，在业界比较早的落地来自于。向量化模型的思路非常简单，如果 Next() 函数只返回一个 Tuple() 的 Overhead 过大，那就每次多返回一些数据，多么简单朴素的 Batch 思想，当然实现复杂度会比原始的迭代模型高一些。示例如下:可以重新对照上文提到的迭代模型看一下差别:不再每次仅返回一个 Tuple，而是返回一组 Tuple (Tuple Batch)因为每次需要返回一组，因此算子内部要维护一个 Buffer，缓存数据后在一并输出。

			
		

	





	

		

			

				
					
Go语言变量的生命周期 【Go语言圣经笔记】

				
			

			

				

					Steve Wang's blog
				

				

					04-22
					
					352
					
				

			

		

		

			
				
摘自：Go语言圣经（简体中文版)

变量的生命周期
变量的生命周期指的是在程序运行期间有效存在的时间段。
对于在包这一级别声明的变量来说，它们的生命周期和整个程序的运行周期是一致的（笔者注：某种程度上讲是静态的）。
相比之下，局部变量的生命周期则是动态的：每次从创建一个新变量的声明语句开始，直到该变量不再被引用为止，然后变量的存储空间可能被回收。
函数的参数变量和返回值都是局部变量，它们在函数每次被调用的时候创建。
下面是一段示例程序：
for t := 0.0; t < cycles*2*math.

			
		

	





	

		

			

				
					
go语言变量的生命周期

				
			

			

				

					Mr_Csyn的博客
				

				

					11-05
					
					384
					
				

			

		

		

			
				
变量的生命周期

变量的生命周期指的是在程序运行期间变量有效存在的时间间隔
全局变量：跟整个程序的运行周期是一样的
局部变量：生命周期是动态的，从创建到不再被使用
形式参数和函数返回值：属于局部变量，在函数调用结束后被销毁

for t := 0.0; t < cycles*2*math.Pi; t += res {
    x := math.Sin(t)
    y := math.Sin(t*freq + phase)
    img.SetColorIndex(
        size+in

			
		

	





	

		

			

				
					
go语言学习-变量生命周期

				
			

			

				

					The Coding World
				

				

					11-06
					
					202
					
				

			

		

		

			
				
package main

var global *int

func f() {
	var x int
	x = 1
	global = &x  
}

func g() {
	y := new(int)
	*y = 1
}

func main() {
	
}


注意：编译器自己选择是在堆或者栈上分配内存，如 x 是堆分配内存，因为它可以通过global访问，y则是栈上分配，它不能...

			
		

	





	

		

			

				
					
06 go启动生命周期M0和G0

				
			

			

				

					wsk8520的博客
				

				

					05-13
					
					2461
					
				

			

		

		

			
				
M0

1、启动程序后的编号为0的主线程(当前启动一个进程时，进程中会包含一个线程，进程中的第一个线程的编号设置为M0)

如果进程中不开任何线程，可以理解为一个进程就是一个线程。

2、在全局变量runtime.M0中，不需要在heap(堆)上分配。(M0在整个进程中是唯一的，无需在堆上分配)

3、负责执行初始化操作和启动第一个G(M0是负责启动第一个G的，go语言是跑在协程上)

4、启动第一个G之后，M0就和其他的M一样了(负责给其他M进行抢占)



G0

1、每次启动一个M，都会第一个创建的.

			
		

	





	

		

			

				
					
go 协程生命周期控制_go携程控制，从理论到实践

				
			

			

				

					2401_84297796的博客
				

				

					04-17
					
					666
					
				

			

		

		

			
				
包来控制协程的取消是Go语言并发编程中的一种常见模式，它为管理和取消协程提供了一种优雅的方式。一旦接收到取消信号，协程就会退出循环并结束执行。time.Sleep(3 * time.Second) // 假设主程序执行了3秒的任务。然后，我们在一个新的协程中启动了一个无限循环的任务，这个任务会定期检查。cancel() // 调用取消函数来发送取消信号。在主函数中，我们模拟了一些任务的执行，然后调用。fmt.Println(“准备取消协程”)fmt.Println(“协程被取消”)函数来发送取消信号。

			
		

	





	

		

			

				
					
Java 会比 Go 长寿？编程语言的生命周期要如何判断

				
			

			

				

					<sdffdsfsdfdfs>sfsfsfsdfsdffds</sdfsDS>Fsd
				

				

					10-03
					
					370
					
				

			

		

		

			
				
点击上方“程序员大咖”，选择“置顶公众号”关键时刻，第一时间送达！预测编程语言的生命周期是非常棘手的事情。1995 年发布的 Java ，到现在依然坚挺，之前有些预测 Java 结局的都很尴尬，而有些新兴语言却只是昙花一现。到底该怎么来判断编程语言的生命周期呢？编程语言的寿命没有先例来做参考，毕竟计算机领域还很“年轻，而且 1954 年创立的 FORTRAN 语言到现在依然有人用。既然如此，是不是

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值