Golang写时复制是否是原子性的？

已于 2022-07-16 07:26:47 修改
阅读量1k 收藏
点赞数 3
分类专栏： Go 文章标签： golang 开发语言 后端
于 2022-07-07 21:45:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiankunking/article/details/125662916
版权

建议先阅读下Go汇编语言的入门教程
https://go.dev/doc/asm

先说一下我这边的一个简化场景吧，有一个定时任务定时从数据库获取数据，也就是对应实例代码中的getNewProject()，获取完数据后，会直接赋给变量projectMap(projectMap其实就是作为一个缓存来用的)；还会有程序从projectMap获取对应的信息。

这个场景其实就是一个简单的写时复制。对于获取在赋值过程中，获取到旧值，也是允许的。

有个疑问点就是在赋值的这个操作是不是原子的呢？

比如示例代码中的第8行。

验证代码:

package main

var (
        projectMap = make(map[string]*Project)
)

func main() {
        projectMap = getNewProject()
}

func getNewProject() map[string]*Project {
        items := make(map[string]*Project)

        item := new(Project)
        item.ID = "project_id"
        item.Name = "project_name"

        items[item.ID] = item
        return items

}

type Project struct {
        ID   string `json:"id"`
        Name string `json:"name"`
}

在网上也找到一些资料，说是原子性的：

  • 看看开源项目都是如何做的
    • https://github.com/fagongzi/manba/blob/master/pkg/proxy/dispatcher_meta.go#L174
  • 看看一些对于Copy-On-Write的讨论
    • https://chunlife.top/2019/09/03/copy-on-write%E6%8A%80%E6%9C%AF/
    • https://github.com/Terry-Mao/gopush-cluster/issues/44

但终究还是自己探索一下的比较好对吧，哈哈。

要想看这个赋值操作是不是原子性的，那咱们看下汇编代码吧。
查看汇编，咱们分为两步：

  • 编译golang代码为.o文件
  • 反编译.o文件
PS D:\Code\Golang\github\jiankunking\cow-test> go tool compile -N -l main\main.go    
PS D:\Code\Golang\github\jiankunking\cow-test> go tool objdump .\main.o              
TEXT "".main(SB) gofile..D:/Code/Golang/github/jiankunking/cow-test/main/main.go                                                    
  main.go:7             0x22f1                  493b6610                CMPQ 0x10(R14), SP                                          
  main.go:7             0x22f5                  763e                    JBE 0x2335                                                  
  main.go:7             0x22f7                  4883ec08                SUBQ $0x8, SP                                               
  main.go:7             0x22fb                  48892c24                MOVQ BP, 0(SP)                                              
  main.go:7             0x22ff                  488d2c24                LEAQ 0(SP), BP                                              
  main.go:8             0x2303                  e800000000              CALL 0x2308             [1:5]R_CALL:"".getNewProject        
  main.go:8             0x2308                  833d0000000000          CMPL $0x0, 0(IP)        [2:6]R_PCREL:runtime.writeBarrier+-1
  main.go:8             0x230f                  6690                    NOPW                                                        
  main.go:8             0x2311                  7402                    JE 0x2315                                                   
  main.go:8             0x2313                  eb09                    JMP 0x231e                                                  
  main.go:8             0x2315                  48890500000000          MOVQ AX, 0(IP)          [3:7]R_PCREL:"".projectMap          
  main.go:8             0x231c                  eb0e                    JMP 0x232c                                                  
  main.go:8             0x231e                  488d3d00000000          LEAQ 0(IP), DI          [3:7]R_PCREL:"".projectMap
  main.go:8             0x2325                  e800000000              CALL 0x232a             [1:5]R_CALL:runtime.gcWriteBarrier<1>
  main.go:8             0x232a                  eb00                    JMP 0x232c
  main.go:9             0x232c                  488b2c24                MOVQ 0(SP), BP
  main.go:9             0x2330                  4883c408                ADDQ $0x8, SP
  main.go:9             0x2334                  c3                      RET
  main.go:7             0x2335                  e800000000              CALL 0x233a             [1:5]R_CALL:runtime.morestack_noctxt
  main.go:7             0x233a                  ebb5                    JMP "".main(SB)

TEXT "".getNewProject(SB) gofile..D:/Code/Golang/github/jiankunking/cow-test/main/main.go
  main.go:11            0x233c                  493b6610                CMPQ 0x10(R14), SP
  main.go:11            0x2340                  0f8600010000            JBE 0x2446
  main.go:11            0x2346                  4883ec58                SUBQ $0x58, SP
  main.go:11            0x234a                  48896c2450              MOVQ BP, 0x50(SP)
  main.go:11            0x234f                  488d6c2450              LEAQ 0x50(SP), BP
  main.go:11            0x2354                  48c744242000000000      MOVQ $0x0, 0x20(SP)
  main.go:12            0x235d                  e800000000              CALL 0x2362                     [1:5]R_CALL:runtime.makemap_small<1>
  main.go:12            0x2362                  4889442428              MOVQ AX, 0x28(SP)
  main.go:14            0x2367                  488d0500000000          LEAQ 0(IP), AX                  [3:7]R_PCREL:type."".Project
  main.go:14            0x236e                  e800000000              CALL 0x2373                     [1:5]R_CALL:runtime.newobject<1>
  main.go:14            0x2373                  4889442430              MOVQ AX, 0x30(SP)
  main.go:15            0x2378                  48c740080a000000        MOVQ $0xa, 0x8(AX)
  main.go:15            0x2380                  833d0000000000          CMPL $0x0, 0(IP)                [2:6]R_PCREL:runtime.writeBarrier+-1
  main.go:15            0x2387                  7402                    JE 0x238b
  main.go:15            0x2389                  eb0c                    JMP 0x2397
  main.go:15            0x238b                  488d1500000000          LEAQ 0(IP), DX                  [3:7]R_PCREL:go.string."project_id"
  main.go:15            0x2392                  488910                  MOVQ DX, 0(AX)
  main.go:15            0x2395                  eb11                    JMP 0x23a8
  main.go:15            0x2397                  4889c7                  MOVQ AX, DI
  main.go:15            0x239a                  488d1500000000          LEAQ 0(IP), DX                  [3:7]R_PCREL:go.string."project_id"
  main.go:15            0x23a1                  e800000000              CALL 0x23a6                     [1:5]R_CALL:runtime.gcWriteBarrierDX
  main.go:15            0x23a6                  eb00                    JMP 0x23a8
  main.go:16            0x23a8                  488b542430              MOVQ 0x30(SP), DX
  main.go:16            0x23ad                  8402                    TESTB AL, 0(DX)
  main.go:16            0x23af                  48c742180c000000        MOVQ $0xc, 0x18(DX)
  main.go:16            0x23b7                  488d7a10                LEAQ 0x10(DX), DI
  main.go:16            0x23bb                  833d0000000000          CMPL $0x0, 0(IP)                [2:6]R_PCREL:runtime.writeBarrier+-1
  main.go:16            0x23c2                  7402                    JE 0x23c6
  main.go:16            0x23c4                  eb0d                    JMP 0x23d3
  main.go:16            0x23c6                  488d3500000000          LEAQ 0(IP), SI                  [3:7]R_PCREL:go.string."project_name"
  main.go:16            0x23cd                  48897210                MOVQ SI, 0x10(DX)
  main.go:16            0x23d1                  eb10                    JMP 0x23e3
  main.go:16            0x23d3                  488d1500000000          LEAQ 0(IP), DX                  [3:7]R_PCREL:go.string."project_name"
  main.go:16            0x23da                  6690                    NOPW
  main.go:16            0x23dc                  e800000000              CALL 0x23e1                     [1:5]R_CALL:runtime.gcWriteBarrierDX
  main.go:16            0x23e1                  eb00                    JMP 0x23e3
  main.go:18            0x23e3                  488b542430              MOVQ 0x30(SP), DX
  main.go:18            0x23e8                  8402                    TESTB AL, 0(DX)
  main.go:18            0x23ea                  488b0a                  MOVQ 0(DX), CX
  main.go:18            0x23ed                  488b7a08                MOVQ 0x8(DX), DI
  main.go:18            0x23f1                  48894c2440              MOVQ CX, 0x40(SP)
  main.go:18            0x23f6                  48897c2448              MOVQ DI, 0x48(SP)
  main.go:18            0x23fb                  488b5c2428              MOVQ 0x28(SP), BX
  main.go:18            0x2400                  488d0500000000          LEAQ 0(IP), AX                  [3:7]R_PCREL:type.map[string]*"".Project        
  main.go:18            0x2407                  e800000000              CALL 0x240c                     [1:5]R_CALL:runtime.mapassign_faststr<1>
  main.go:18            0x240c                  4889442438              MOVQ AX, 0x38(SP)
  main.go:18            0x2411                  8400                    TESTB AL, 0(AX)
  main.go:18            0x2413                  488b542430              MOVQ 0x30(SP), DX
  main.go:18            0x2418                  833d0000000000          CMPL $0x0, 0(IP)                [2:6]R_PCREL:runtime.writeBarrier+-1
  main.go:18            0x241f                  7402                    JE 0x2423
  main.go:18            0x2421                  eb05                    JMP 0x2428
  main.go:18            0x2423                  488910                  MOVQ DX, 0(AX)
  main.go:18            0x2426                  eb0a                    JMP 0x2432
  main.go:18            0x2428                  4889c7                  MOVQ AX, DI
  main.go:18            0x242b                  e800000000              CALL 0x2430                     [1:5]R_CALL:runtime.gcWriteBarrierDX
  main.go:18            0x2430                  eb00                    JMP 0x2432
  main.go:19            0x2432                  488b442428              MOVQ 0x28(SP), AX
  main.go:19            0x2437                  4889442420              MOVQ AX, 0x20(SP)
  main.go:19            0x243c                  488b6c2450              MOVQ 0x50(SP), BP
  main.go:19            0x2441                  4883c458                ADDQ $0x58, SP
  main.go:19            0x2445                  c3                      RET
  main.go:11            0x2446                  e800000000              CALL 0x244b                     [1:5]R_CALL:runtime.morestack_noctxt
  main.go:11            0x244b                  e9ecfeffff              JMP "".getNewProject(SB)

TEXT "".init(SB) gofile..D:/Code/Golang/github/jiankunking/cow-test/main/main.go
  main.go:4             0x2450                  493b6610                CMPQ 0x10(R14), SP
  main.go:4             0x2454                  763e                    JBE 0x2494
  main.go:4             0x2456                  4883ec08                SUBQ $0x8, SP
  main.go:4             0x245a                  48892c24                MOVQ BP, 0(SP)
  main.go:4             0x245e                  488d2c24                LEAQ 0(SP), BP
  main.go:4             0x2462                  e800000000              CALL 0x2467             [1:5]R_CALL:runtime.makemap_small<1>
  main.go:4             0x2467                  833d0000000000          CMPL $0x0, 0(IP)        [2:6]R_PCREL:runtime.writeBarrier+-1
  main.go:4             0x246e                  6690                    NOPW
  main.go:4             0x2470                  7402                    JE 0x2474
  main.go:4             0x2472                  eb09                    JMP 0x247d
  main.go:4             0x2474                  48890500000000          MOVQ AX, 0(IP)          [3:7]R_PCREL:"".projectMap
  main.go:4             0x247b                  eb0e                    JMP 0x248b
  main.go:4             0x247d                  488d3d00000000          LEAQ 0(IP), DI          [3:7]R_PCREL:"".projectMap
  main.go:4             0x2484                  e800000000              CALL 0x2489             [1:5]R_CALL:runtime.gcWriteBarrier<1>
  main.go:4             0x2489                  eb00                    JMP 0x248b
  main.go:4             0x248b                  488b2c24                MOVQ 0(SP), BP
  main.go:4             0x248f                  4883c408                ADDQ $0x8, SP
  main.go:4             0x2493                  c3                      RET
  main.go:4             0x2494                  e800000000              CALL 0x2499             [1:5]R_CALL:runtime.morestack_noctxt
  main.go:4             0x2499                  ebb5                    JMP "".init(SB)

TEXT type..eq."".Project(SB) gofile..<autogenerated>
  gofile..<autogenerated>:1     0x2713                  493b6610                CMPQ 0x10(R14), SP
  gofile..<autogenerated>:1     0x2717                  0f8610010000            JBE 0x282d
  gofile..<autogenerated>:1     0x271d                  4883ec58                SUBQ $0x58, SP
  gofile..<autogenerated>:1     0x2721                  48896c2450              MOVQ BP, 0x50(SP)
  gofile..<autogenerated>:1     0x2726                  488d6c2450              LEAQ 0x50(SP), BP
  gofile..<autogenerated>:1     0x272b                  4889442460              MOVQ AX, 0x60(SP)
  gofile..<autogenerated>:1     0x2730                  48895c2468              MOVQ BX, 0x68(SP)
  gofile..<autogenerated>:1     0x2735                  c644241e00              MOVB $0x0, 0x1e(SP)
  gofile..<autogenerated>:1     0x273a                  488b542460              MOVQ 0x60(SP), DX
  gofile..<autogenerated>:1     0x273f                  488b5208                MOVQ 0x8(DX), DX
  gofile..<autogenerated>:1     0x2743                  4889542428              MOVQ DX, 0x28(SP)
  gofile..<autogenerated>:1     0x2748                  488b542468              MOVQ 0x68(SP), DX
  gofile..<autogenerated>:1     0x274d                  488b5208                MOVQ 0x8(DX), DX
  gofile..<autogenerated>:1     0x2751                  4889542420              MOVQ DX, 0x20(SP)
  gofile..<autogenerated>:1     0x2756                  4839542428              CMPQ DX, 0x28(SP)
  gofile..<autogenerated>:1     0x275b                  7405                    JE 0x2762
  gofile..<autogenerated>:1     0x275d                  e9b3000000              JMP 0x2815
  gofile..<autogenerated>:1     0x2762                  eb00                    JMP 0x2764
  gofile..<autogenerated>:1     0x2764                  488b542460              MOVQ 0x60(SP), DX
  gofile..<autogenerated>:1     0x2769                  488b5218                MOVQ 0x18(DX), DX
  gofile..<autogenerated>:1     0x276d                  4889542420              MOVQ DX, 0x20(SP)
  gofile..<autogenerated>:1     0x2772                  488b542468              MOVQ 0x68(SP), DX
  gofile..<autogenerated>:1     0x2777                  488b5218                MOVQ 0x18(DX), DX
  gofile..<autogenerated>:1     0x277b                  4889542428              MOVQ DX, 0x28(SP)
  gofile..<autogenerated>:1     0x2780                  4839542420              CMPQ DX, 0x20(SP)
  gofile..<autogenerated>:1     0x2785                  7405                    JE 0x278c
  gofile..<autogenerated>:1     0x2787                  e987000000              JMP 0x2813
  gofile..<autogenerated>:1     0x278c                  eb00                    JMP 0x278e
  gofile..<autogenerated>:1     0x278e                  488b542460              MOVQ 0x60(SP), DX
  gofile..<autogenerated>:1     0x2793                  488b5208                MOVQ 0x8(DX), DX
  gofile..<autogenerated>:1     0x2797                  4889542428              MOVQ DX, 0x28(SP)
  gofile..<autogenerated>:1     0x279c                  488b542460              MOVQ 0x60(SP), DX
  gofile..<autogenerated>:1     0x27a1                  488b12                  MOVQ 0(DX), DX
  gofile..<autogenerated>:1     0x27a4                  4889542448              MOVQ DX, 0x48(SP)
  gofile..<autogenerated>:1     0x27a9                  488b542468              MOVQ 0x68(SP), DX
  gofile..<autogenerated>:1     0x27ae                  488b1a                  MOVQ 0(DX), BX
  gofile..<autogenerated>:1     0x27b1                  48895c2440              MOVQ BX, 0x40(SP)
  gofile..<autogenerated>:1     0x27b6                  488b4c2428              MOVQ 0x28(SP), CX
  gofile..<autogenerated>:1     0x27bb                  488b442448              MOVQ 0x48(SP), AX
  gofile..<autogenerated>:1     0x27c0                  e800000000              CALL 0x27c5                     [1:5]R_CALL:runtime.memequal<1>
  gofile..<autogenerated>:1     0x27c5                  8844241f                MOVB AL, 0x1f(SP)
  gofile..<autogenerated>:1     0x27c9                  84c0                    TESTL AL, AL
  gofile..<autogenerated>:1     0x27cb                  7502                    JNE 0x27cf
  gofile..<autogenerated>:1     0x27cd                  eb41                    JMP 0x2810
  gofile..<autogenerated>:1     0x27cf                  eb00                    JMP 0x27d1
  gofile..<autogenerated>:1     0x27d1                  488b542460              MOVQ 0x60(SP), DX
  gofile..<autogenerated>:1     0x27d6                  488b5218                MOVQ 0x18(DX), DX
  gofile..<autogenerated>:1     0x27da                  4889542428              MOVQ DX, 0x28(SP)
  gofile..<autogenerated>:1     0x27df                  488b542460              MOVQ 0x60(SP), DX
  gofile..<autogenerated>:1     0x27e4                  488b5210                MOVQ 0x10(DX), DX
  gofile..<autogenerated>:1     0x27e8                  4889542438              MOVQ DX, 0x38(SP)
  gofile..<autogenerated>:1     0x27ed                  488b542468              MOVQ 0x68(SP), DX
  gofile..<autogenerated>:1     0x27f2                  488b5a10                MOVQ 0x10(DX), BX
  gofile..<autogenerated>:1     0x27f6                  48895c2430              MOVQ BX, 0x30(SP)
  gofile..<autogenerated>:1     0x27fb                  488b4c2428              MOVQ 0x28(SP), CX
  gofile..<autogenerated>:1     0x2800                  488b442438              MOVQ 0x38(SP), AX
  gofile..<autogenerated>:1     0x2805                  e800000000              CALL 0x280a                     [1:5]R_CALL:runtime.memequal<1>
  gofile..<autogenerated>:1     0x280a                  8844241e                MOVB AL, 0x1e(SP)
  gofile..<autogenerated>:1     0x280e                  eb0e                    JMP 0x281e
  gofile..<autogenerated>:1     0x2810                  eb05                    JMP 0x2817
  gofile..<autogenerated>:1     0x2812                  90                      NOPL
  gofile..<autogenerated>:1     0x2813                  eb02                    JMP 0x2817
  gofile..<autogenerated>:1     0x2815                  eb00                    JMP 0x2817
  gofile..<autogenerated>:1     0x2817                  c644241e00              MOVB $0x0, 0x1e(SP)
  gofile..<autogenerated>:1     0x281c                  eb00                    JMP 0x281e
  gofile..<autogenerated>:1     0x281e                  0fb644241e              MOVZX 0x1e(SP), AX
  gofile..<autogenerated>:1     0x2823                  488b6c2450              MOVQ 0x50(SP), BP
  gofile..<autogenerated>:1     0x2828                  4883c458                ADDQ $0x58, SP
  gofile..<autogenerated>:1     0x282c                  c3                      RET
  gofile..<autogenerated>:1     0x282d                  4889442408              MOVQ AX, 0x8(SP)
  gofile..<autogenerated>:1     0x2832                  48895c2410              MOVQ BX, 0x10(SP)
  gofile..<autogenerated>:1     0x2837                  e800000000              CALL 0x283c                     [1:5]R_CALL:runtime.morestack_noctxt    
  gofile..<autogenerated>:1     0x283c                  488b442408              MOVQ 0x8(SP), AX
  gofile..<autogenerated>:1     0x2841                  488b5c2410              MOVQ 0x10(SP), BX
  gofile..<autogenerated>:1     0x2846                  e9c8feffff              JMP type..eq."".Project(SB)
PS D:\Code\Golang\github\jiankunking\cow-test>

先从汇编代码中摘取出，第8行代码对应的汇编

  main.go:8             0x2303                  e800000000              CALL 0x2308             [1:5]R_CALL:"".getNewProject        
  main.go:8             0x2308                  833d0000000000          CMPL $0x0, 0(IP)        [2:6]R_PCREL:runtime.writeBarrier+-1
  main.go:8             0x230f                  6690                    NOPW                                                        
  main.go:8             0x2311                  7402                    JE 0x2315                                                   
  main.go:8             0x2313                  eb09                    JMP 0x231e                                                  
  main.go:8             0x2315                  48890500000000          MOVQ AX, 0(IP)          [3:7]R_PCREL:"".projectMap          
  main.go:8             0x231c                  eb0e                    JMP 0x232c                                                  
  main.go:8             0x231e                  488d3d00000000          LEAQ 0(IP), DI          [3:7]R_PCREL:"".projectMap
  main.go:8             0x2325                  e800000000              CALL 0x232a             [1:5]R_CALL:runtime.gcWriteBarrier<1>
  main.go:8             0x232a                  eb00                    JMP 0x232c

从汇编代码中可以看出，赋值的核心在下面这几句：

// 将AX寄存器中的值赋给0(IP)
  main.go:8             0x2315                  48890500000000          MOVQ AX, 0(IP)          [3:7]R_PCREL:"".projectMap          
// 跳转
  main.go:8             0x231c                  eb0e                    JMP 0x232c                                                  
// 将0(IP)中值的地址赋给DI
  main.go:8             0x231e                  488d3d00000000          LEAQ 0(IP), DI          [3:7]R_PCREL:"".projectMap

从汇编可以看到赋值是只有一步，但获取值及赋值是分开的，也就是说对于写时复制这种场景来说，直接赋值是没有问题的

基础知识补充:

MOVQ

  • movb(8位)、movw(16位)、movl(32位)、movq(64位)

  • 寄存器寻址：

movl %eax, %edx
eax -> edx

https://blog.csdn.net/luoyhang003/article/details/46786591/

TESTB

TEST指令的行为与AND指令一样，除了不改变目的寄存器的值。例如，testq %rax, %rax 用来检查 %rax 是负数、零、还是正数。

LEAQ vs MOVQ

https://stackoverflow.com/questions/1699748/what-is-the-difference-between-mov-and-lea

PCDATA

https://www.cnblogs.com/binHome/p/13034103.html

CMPL

CMPL %eax，%ebx
==> 
[ebx]-[eax],就是把第二个数减去第一个数

JMP

无条件转移指令
JMP 389无条件转至0x0185地址处(十进制389转换成十六进制0x0185)

CALL

调用函数
CALL runtime.printnl(SB)表示通过printnl函数的内存地址发起调用

伪计数器

FP: Frame pointer: arguments and locals.(指向当前栈帧)
PC: Program counter: jumps and branches.(指向指令地址)
SB: Static base pointer: global symbols.(指向全局符号表)
SP: Stack pointer: top of stack.(指向当前栈顶部)
注意: 栈是向下整长 golang的汇编是调用者维护参数返回值跟返回地址。所以FP的值小于参数跟返回值

本机环境

在这里插入图片描述

x86-64（ 又称x64，即英文词64-bit extended，64位拓展 的简写）是x86架构的64位拓展，向后兼容于16位及32位的x86架构。x64于1999年由AMD设计，AMD首次公开64位集以扩展给x86，称为“AMD64”。

编译命令详解

PS D:\Code\Golang\github\jiankunking\cow-test> go tool compile -help
usage: compile [options] file.go...
  -% int
        debug non-static initializers
  -+    compiling runtime
  -B    disable bounds checking
  -C    disable printing of columns in error messages
  -D path
        set relative path for local imports
  -E    debug symbol export
  -G    accept generic code (default 3)
  -I directory
        add directory to import search path
  -K    debug missing line numbers
  -L    show full file names in error messages
  -N    disable optimizations
  -S    print assembly listing
  -V    print version and exit
  -W    debug parse tree after type checking
  -asan
        build code compatible with C/C++ address sanitizer
  -asmhdr file
        write assembly header to file
  -bench file
        append benchmark times to file
  -blockprofile file
        write block profile to file
  -buildid id
        record id as the build id in the export metadata
  -c int
        concurrency during compilation (1 means no concurrency) (default 1)
  -clobberdead
        clobber dead stack slots (for debugging)
  -clobberdeadreg
        clobber dead registers (for debugging)
  -complete
        compiling complete package (no C or assembly)
  -cpuprofile file
        write cpu profile to file
  -d value
        enable debugging settings; try -d help
  -dwarf
        generate DWARF symbols (default true)
  -dwarfbasentries
        use base address selection entries in DWARF (default true)
  -dwarflocationlists
        add location lists to DWARF in optimized mode (default true)
  -dynlink
        support references to Go symbols defined in other shared libraries
  -e    no limit on number of errors reported
  -embedcfg file
        read go:embed configuration from file
  -gendwarfinl int
        generate DWARF inline info records (default 2)
  -goversion string
        required version of the runtime
  -h    halt on error
  -importcfg file
        read import configuration from file
  -importmap definition
        add definition of the form source=actual to import map
  -installsuffix suffix
        set pkg directory suffix
  -j    debug runtime-initialized variables
  -json string
        version,file for JSON compiler/optimizer detail output
  -l    disable inlining
  -lang string
        Go language version source code expects
  -linkobj file
        write linker-specific object to file
  -linkshared
        generate code that will be linked against Go shared libraries
  -live
        debug liveness analysis
  -m    print optimization decisions
  -memprofile file
        write memory profile to file
  -memprofilerate rate
        set runtime.MemProfileRate to rate
  -msan
        build code compatible with C/C++ memory sanitizer
  -mutexprofile file
        write mutex profile to file
  -nolocalimports
        reject local (relative) imports
  -o file
        write output to file
  -p path
        set expected package import path
  -pack
        write to file.a instead of file.o
  -r    debug generated wrappers
  -race
        enable race detector
  -shared
        generate code that can be linked into a shared library
  -smallframes
        reduce the size limit for stack allocated objects
  -spectre list
        enable spectre mitigations in list (all, index, ret)
  -std
        compiling standard library
  -symabis file
        read symbol ABIs from file
  -t    enable tracing for debugging the compiler
  -traceprofile file
        write an execution trace to file
  -trimpath prefix
        remove prefix from recorded source file paths
  -v    increase debug verbosity
  -w    debug type checking
  -wb
        enable write barrier (default true)

拓展阅读

https://stackoverflow.com/questions/70332316/whats-the-differenct-between-go-tool-compile-and-go-tool-objdump

https://xargin.com/plan9-assembly/

https://github.com/cch123/golang-notes/blob/master/assembly.md

https://go.dev/doc/asm

衣舞晨风
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Golang使用lua脚本实现redis原子操作
12-20
目录 [redis 调用Lua脚本](#redis 调用Lua脚本) [redis+lua 实现评分排行榜实时更新](#redis+lua 实现评分排行榜实时更新) [lua 脚本](#lua 脚本) Golang调用redis+lua示例 byte切片与string的转换优化 redis 调用Lua脚本 EVAL命令 redis调用Lua脚本需要使用EVAL命令。 redis EVAL命令格式： redis 127.0.0.1:6379> EVAL script numkeys key [key …] arg [arg …] 最简单的例子： 127.0.0.1:6379
golang之两个结构体复制字段
01-08
实际工作中可能会有这样的场景: 两个结构体(可能类型一样), 字段名和类型都一样, 想复制一个结构体的全部或者其中某几个字段的值到另一个(即merge操作), 自然想到可以用反射实现. package main import fmt import reflect // 用b的所有字段覆盖a的 // 如果fields不为空, 表示用b的特定字段覆盖a的 // a应该为结构体指针 func CopyFields(a interface{}, b interface{}, fields ...string) (err error) { at := reflect.TypeOf(a) av
Golang读写Excel的方法教程
09-21
主要给大家介绍了关于Golang读写Excel的方法教程，golang操作excel利用的是Excelize，Excelize是Golang编写的一个用来操作 Office Excel 文档类库，基于微软的Office OpenXML标准，文中介绍的非常详细，需要的朋友可以参考借鉴，下面来一起看看吧。
linux全局变量加读写锁,Golang全局变量加锁的问题解决
weixin_32540969的博客
05-12 374
如果全局变量只读取 那自然是不需要加锁的如果全局变量多进程读，多进程写，那自然是需要加读写锁的但是如果全局变量只有一个进程写，其他进程读呢？ 如果采用COW的方式，写进程只是通过单次赋值的方式来更新变量，是否就可以不加锁了呢？就第三种情况而言：当然我们通过 go build -race 或者 go run -race 就会出现WARNING: DATA RACE。 但是出现 data race 就...
【golang】理解Golang赋值的并发安全性
最新发布
IT部落格
11-29 171
并发安全就是程序在并发情况下执行的结果是正确的。比如对一个变量简单的自增操作count++，在非并发下很好理解，而在并发情况下却容易出现预期之外的结果，这样的代码就是非并发安全的。因为count++其实是分成两步执行的，当分成了两步执行，那么其他协程就可以趁着这个时间间隙作怪。count:= 1a > 读取count : 1b > 读取count : 1a > 计算count+1 : 2b > 计算count+1 : 2a > 赋值count : 2b > 赋值count : 2。
golang copy-on-write思想应用
qq_16059847的博客
04-26 1719
copy-on-write 是计算机领域相当经典的优化思想，当然你如果问一个Java 开发者 copy-on-write 有什么作用？他们往往第一反应就是：优雅地解决读多写少场景下的并发问题。 确实，众所周知，多线程环境下会出现 data race 的问题，我们以 Java 中的 ArrayList 为例，ArrayList 本身是不保证线程安全的，通常情况，要保证多线程环境下不出问题，就要给 ArrayList 加上读写锁，读要读锁，写要写锁，读与读之间不互斥，读与写之间要互斥，写与写之间也要互斥。
Golang 复制文件的三种做法
wanghailan1818的博客
02-28 3436
主要介绍三种复制文件的方法： 使用io.Copy()方法 一次性读取输入文件，然后再一次性写入目标文件 使用buffer一块块地复制文件 方法一 ： 使用io.Copy func copy(src, dst string) (int64, error) { sourceFileStat, err := os.Stat(src) if err != nil { return 0, err } if !sourceFileStat.Mode().IsRegular()
golang并发编程-01多进程编程-01概述
运维玄德公
05-04 1400
1. 基本概念 1.1 串行程序与并发程序 1.2 并发程序与并行程序 1.3 并发程序与并发系统 1.4 并发程序内部的交互 2. 多进程编程 2.1 常用IPC方法 2.2 进程 2.3 同步 2.4 管道
在CSDN学Golang云原生（Docker镜像）
YKM_2580的博客
07-24 726
最后，它返回容器的根路径。在执行这个 Dockerfile 的过程中，Docker 会将每个指令生成的结果保存为一个新的分层，并将它们合并成最终的镜像。需要注意的是，在编写 Dockerfile 文件时，应该尽量遵循最佳实践，避免一些常见问题，如不必要的安装软件包、不规范的文件权限等。在golang中，镜像内容寻址机制指的是程序在运行时如何查找和访问已经编译好的包文件。无论是哪种方式，都需要遵循最佳实践制作好 Golang 镜像，并确保该镜像具有较高的可重复性和稳定性，在生产环境中能够正常运行。
golang 原子操作
weixin_30687811的博客
03-21 439
原文：http://ifeve.com/go-concurrency-atomic/ 1. 什么是原子操作 　　我们已经知道，原子操作即是进行过程中不能被中断的操作。也就是说，针对某个值的原子操作在被进行的过程当中，CPU绝不会再去进行其它的针对该值的操作。无论这些其它的操作是否为原子操作都会是这样。为了实现这样的严谨性，原子操作仅会由一个独立的CPU指令代表和完成。只有这样才能够...
Golang同步：原子操作使用
热门推荐
巴途Way,专注Go,PHP,C开发
11-29 1万+
原子操作即是进行过程中不能被中断的操作。针对某个值的原子操作在被进行的过程中，CPU绝不会再去进行其他的针对该值的操作。 为了实现这样的严谨性，原子操作仅会由一个独立的CPU指令代表和完成。GO语言提供的原子操作都是非入侵式的，由标准库sync/atomic中的众多函数代表 类型包括int32,int64,uint32,uint64,uintptr,unsafe.Pointer，共六个。 这些
golang lockfree
climbs的专栏
08-15 434
Lock-free 算法的基础是 CAS (Compareand-Swap) 原子操作。当某个地址的原始值等于某个比较值时，把值改成新值，无论有否修改，返回这个地址的原始值。目前的cpu 支持最多64位的CAS。并且指针 p 必须对齐。 注：原子操作指一个cpu时钟周期内就可以完成的操作，不会被其他线程干扰。 一般的 CAS 使用方式是： 假设有指针 p, 它指向一个 32 位或者64位数， 复制p 的内容（*p）到比较量 cmp （原子操作） 基于这个比较量计算一个新值 xchg (非原子操作.
写时复制copyonwrite的demo，示例
aaqq123456654321的博客
03-03 166
阅读etcd源码时候，看到一个写时复制的实现，纪录一下 package main import "fmt" type pgid uint64 type txid uint64 type meta struct { magic uint32 version uint32 pageSize uint32 flags uint32 freelist pgid pgid pgid txid txid checksum uint64 } func main()
2021-03-06：go中，公共变量是协程安全吗？赋值操作是原子的吗？为什么？
福大大架构师每日一题
03-06 5032
2021-03-06：go中，公共变量是协程安全吗？赋值操作是原子的吗？为什么？ 福哥答案2021-03-06： 这是面试中被问到的。实力有限，真正的答案还不知道。我的想法是a=1是原子操作，a=b不是原子操作。实际开发中，不大可能是a=1这种情况，可以说是协程不安全。 答案1： 不是协程安全的， 赋值非原子操作， 需要加锁要么就做原子操作， 否则会引起data race。 评论如下： 题016_ 卓熊 7:39:15 Go很多操作并没有做太多处理，还是沿用了c。所以公共变量非协程安全，赋值操作是否原子跟变
go-值赋值和引用赋值
liulanba的博客
10-30 303
通过 copy 函数将 ls 的元素复制到 lk，并修改了 lk[1] 的值，这个修改只会影响到 lk 自身，不会影响 ls。修改目标切片 lk 中的元素值不会影响原始切片 ls，因为它们引用的是不同的内存空间。当对 p1 的字段进行修改时，p3 不会受到影响，因为它们引用的是不同的内存地址。这意味着目标变量和源变量是完全独立的，它们引用的是不同的内存地址。修改目标变量的值不会影响源变量的值。当进行引用赋值时，目标变量和源变量引用的是相同的底层数据。需要注意的是，值赋值和引用赋值的行为取决于变量的类型。
Golang学习笔记：原子操作
sublio的博客
06-02 897
转载请注明出处： 全系列目录：https://blog.csdn.net/sublio/article/details/106480267 原子操作 目录 简介 类型 增或减Add 比较并交换CAS 载入Load 存储Store 交换Swap 原子值sync/atomic.Value 简介 执行过程中不能被中断的操作。在针对某个值的操作过程中，CPU绝不会再去执行其它针对该值的操作，无论这些其他操作是否是原子操作。 对于不能被取地址的值是无法进行原子操作的。 类型
Copy-on-Write模式：写时复制
weixin_43719015的博客
04-22 5105
话题：Copy-on-Write模式：不是延时策略的COW 在上一篇文章中我们讲到Java里String这个类在实现replace()方法的时候，并没有更改原字符串里面value[]数组的内容，而是创建了一个新字符串，这种方法在解决不可变对象的修改问题时经常用到。如果你深入地思考这个方法，你会发现它本质上是一种Copy-on-Write方法。所谓Copy-on-Write，经常被缩写为COW或者C...
Go 五种原子性操作的用法详解
EDDYCJY的博客
10-12 1436
本文我们详细聊一下Go语言的原子操作的用法，啥是原子操作呢？顾名思义，原子操作就是具备原子性的操作... 是不是感觉说了跟没说一样，原子性的解释如下：一个或者多个操作在 CPU 执行的过程...
Golang中的原子操作详解
金戈鐡馬
03-27 1518
原子操作是变量级别的互斥锁。原子操作是变量级别的互斥锁。简单来说，就是同一时刻，只能有一个 CPU 对变量进行读或写。当我们想要对某个变量做并发安全的修改，除了使用官方提供的Mutex，还可以使用包的原子操作， 它能够保证对变量的读取或修改期间不被其他的协程所影响。我们可以用下图来表示：说明：在上图中，我们有三个 CPU 逻辑核，其中 CPU 1 正在对变量v做原子操作，这个时候 CPU 2 和 CPU 3 不能对v做任何操作， 在 CPU 1 操作完成后，CPU 2 和 CPU 3 可以获取到v。
golang操作的原子性
10-01
在Go语言中，原子操作是具备原子性的操作，它们可以确保在并发环境下的数据同步和线程安全。原子操作是不可中断的，不会被其他线程或进程打断。在Go语言中，我们可以使用atomic包提供的原子操作函数来实现原子操作。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值