雪松的博客(专注于Golang、Rust、分布式架构、DB)

Go1.18调度器-内核函数

2022-04-22T00:00:00+00:00

内核函数

某些内核专用的函数，比如休眠、唤醒等。

gopark, goready

休眠函数gopark解除当前G和MP的绑定，让MP去执行其他任务。重点是G没有放回任务队列，除非被唤醒，否则再不会被调度执行。

// proc.go

// Puts the current goroutine into a waiting state and calls unlockf on the
// system stack.
//
// If unlockf returns false, the goroutine is resumed.

func gopark(unlockf func(*g, unsafe.Pointer) bool, lock unsafe.Pointer, reason waitReason, traceEv byte, traceskip int) {
    mp := acquirem()
       gp := mp.curg
    
    status := readgstatus(gp)
    if status != _Grunning && status != _Gscanrunning {
        throw("gopark: bad g status")
    }

    mp.waitlock = lock
    mp.waitunlockf = unlockf
    gp.waitreason = reason

    releasem(mp)
    
    // can't do anything that might move the G between Ms here.
    mcall(park_m)
}

// park continuation on g0.

func park_m(gp *g) {
    _g_ := getg()

    // 修改状态，解除 MP 绑定。
    // 该任务让出执行绪，但未放回队列。
    casgstatus(gp, _Grunning, _Gwaiting)
    dropg()

    // 调用 unlock 函数。
    if fn := _g_.m.waitunlockf; fn != nil {
        ok := fn(gp, _g_.m.waitlock)
        _g_.m.waitunlockf = nil
        _g_.m.waitlock = nil

        // 失败！继续执行 G 任务。
        if !ok {
            casgstatus(gp, _Gwaiting, _Grunnable)
            execute(gp, true) // Schedule it back, never returns.
        }
    }
    
    // 当前 MP 继续执行其他任务。
    schedule()
}

// dropg removes the association between m and the current goroutine m->curg (gp for short).
func dropg() {
    _g_ := getg()

    // 解除当前`G`和 `M`的绑定
    setMNoWB(&_g_.m.curg.m, nil)
    setGNoWB(&_g_.m.curg, nil)
}

与之配套的是goready函数。它负责将park G放回队列，可设为runnext任务。

func goready(gp *g, traceskip int) {
    systemstack(func() {
        ready(gp, traceskip, true)
    })
}

// Mark gp ready to run.
func ready(gp *g, traceskip int, next bool) {

    status := readgstatus(gp)

    // Mark runnable.
    _g_ := getg()
    mp := acquirem() // disable preemption because it can be holding p in a local var
    
    // 必须是 park G。
    if status&^_Gscan != _Gwaiting {
        dumpgstatus(gp)
        throw("bad g->status in ready")
    }

    // 修改状态，重新放回队列。
    casgstatus(gp, _Gwaiting, _Grunnable)
    runqput(_g_.m.p.ptr(), gp, next)
    
    // 有新任务，唤醒闲置 MP 工作。
    wakep()
    
    releasem(mp)
}

notesleep

该休眠函数不解除MP关联，适合一些自旋(spanning)等待场合。

像 Linux、freebsd基于futex实现，其他操作系统使用信号量(semaphore)。

Futex通常称作“快速用户区互斥”，是一种在用户空间实现的锁(互斥)机制。

多执行单位(进程或线程)通过共享同一块内存(整数)未实现等待和唤醒操作。

因为Futex只在操作结果不一致时才进入内核仲裁，所以有非常高的执行效率。

更多内容请参考 man 2 futex.

基于futex实现的lock/unlock，参考《8.其他》

// runtime2.go

type m struct {
    park note
}

// sleep and wakeup on one-time events.
// before any calls to notesleep or notewakeup,
// must call noteclear to initialize the Note.
// then, exactly one thread can call notesleep
// and exactly one thread can call notewakeup (once).
// once notewakeup has been called, the notesleep
// will return.  future notesleep will return immediately.
// subsequent noteclear must be called only after
// previous notesleep has returned, e.g. it's disallowed
// to call noteclear straight after notewakeup.
//
// notetsleep is like notesleep but wakes up after
// a given number of nanoseconds even if the event
// has not yet happened.  if a goroutine uses notetsleep to
// wake up early, it must wait to call noteclear until it
// can be sure that no other goroutine is calling
// notewakeup.

type note struct {
    // Futex-based impl treats it as uint32 key,
    // while sema-based impl as M* waitm.
    // Used to be a union, but unions break precise GC.
    key uintptr
}

围绕 note.key 值进行休眠和唤醒操作。

// lock_futex.go
//
// 休眠(notesleep)和唤醒(notewakeup)调用之前，需要进行初始化(noteclear)。

// 休眠
func notesleep(n *note) {
    gp := getg()
    if gp != gp.m.g0 {
        throw("notesleep not on g0")
    }
    
    ns := int64(-1)
    
    for atomic.Load(key32(&n.key)) == 0 {
        gp.m.blocked = true

        // 如果 key == 0，休眠。（ns < 0，表示不超时）
        // 直到 key 改变，跳出循环。
        futexsleep(key32(&n.key), 0, ns)

        gp.m.blocked = false
    }
}

// 唤醒
func notewakeup(n *note) {
    
    // 修改 key，返回原有值。
    old := atomic.Xchg(key32(&n.key), 1)
    
    if old != 0 {
        print("notewakeup - double wakeup (", old, ")\n")
        throw("notewakeup - double wakeup")
    }
    
    // 唤醒 1 个等待。
    futexwakeup(key32(&n.key), 1)
}

// One-time notifications.
func noteclear(n *note) {
    n.key = 0
}

Futex

具体实现依赖操作系统提供。

// os_linux.go

// Atomically,
//	if(*addr == val) sleep
// Might be woken up spuriously; that's allowed.
// Don't sleep longer than ns; ns < 0 means forever.

func futexsleep(addr *uint32, val uint32, ns int64) {
    
    // Some Linux kernels have a bug where futex of
    // FUTEX_WAIT returns an internal error code
    // as an errno. Libpthread ignores the return value
    // here, and so can we: as it says a few lines up,
    // spurious wakeups are allowed.
    if ns < 0 {
        futex(unsafe.Pointer(addr), _FUTEX_WAIT_PRIVATE, val, nil, nil, 0)
        return
    }

    var ts timespec
    ts.setNsec(ns)
    
    futex(unsafe.Pointer(addr), _FUTEX_WAIT_PRIVATE, val, unsafe.Pointer(&ts), nil, 0)
}

// If any procs are sleeping on addr, wake up at most cnt.
func futexwakeup(addr *uint32, cnt uint32) {
    ret := futex(unsafe.Pointer(addr), _FUTEX_WAKE_PRIVATE, cnt, nil, nil, 0)
    if ret >= 0 {
        return
    }

    // I don't know that futex wakeup can return
    // EAGAIN or EINTR, but if it does, it would be
    // safe to loop and call futex again.
    systemstack(func() {
        print("futexwakeup addr=", addr, " returned ", ret, "\n")
    })

    *(*int32)(unsafe.Pointer(uintptr(0x1006))) = 0x1006
}

Go1.18调度器-标准库函数

2022-04-21T00:00:00+00:00

标准库函数

标准库里与调度相关的几个函数。了解实现细节，以便放心使用。

runtime.Gosched

让出当前 G 执行绪。与 gopark 的区别，G 会被放回队列，无需 goready 唤醒。

// Gosched yields the processor, allowing other goroutines to run. It does not
// suspend the current goroutine, so execution resumes automatically.
func Gosched() {
    mcall(gosched_m)
}

// Gosched continuation on g0.
func gosched_m(gp *g) {
    // 继续运行 G0
    goschedImpl(gp)
}

// func mcall(fn func(*g))
// Switch to m->g0's stack, call fn(g).
// Fn must never return. It should gogo(&g->sched)
// to keep running g.
TEXT runtime·mcall<ABIInternal>(SB), NOSPLIT, $0-8
    MOVQ    AX, DX              // DX = fn
    
    // save state in g->sched
    MOVQ    0(SP), BX           // caller's PC
    MOVQ    BX, (g_sched+gobuf_pc)(R14)
    LEAQ    fn+0(FP), B         // caller's SP
    MOVQ    BX, (g_sched+gobuf_sp)(R14)
    MOVQ    BP, (g_sched+gobuf_bp)(R14)
    
    // switch to m->g0 & its stack, call fn
    MOVQ    g_m(R14), BX
    MOVQ    m_g0(BX), SI        // SI = g.m.g0
    CMPQ    SI, R14             // if g == m->g0 call badmcall
    JNE goodm
    JMP runtime·badmcall(SB)
goodm:
    MOVQ    R14, AX             // AX (and arg 0) = g
    MOVQ    SI, R14             // g = g.m.g0
    get_tls(CX)                 // Set G in TLS
    MOVQ    R14, g(CX)
    MOVQ    (g_sched+gobuf_sp)(R14), SP // sp = g0.sched.sp
    PUSHQ   AX                  // open up space for fn's arg spill slot
    MOVQ    0(DX), R12
    CALL    R12                 // fn(g)
    POPQ    AX
    JMP runtime·badmcall2(SB)
    RET

func goschedImpl(gp *g) {

    // 修改状态
    status := readgstatus(gp)
    if status&^_Gscan != _Grunning {
        dumpgstatus(gp)
        throw("bad g status")
    }
    casgstatus(gp, _Grunning, _Grunnable)

    // 解除 MP 绑定，放回全局队列
    dropg()
    lock(&sched.lock)
    globrunqput(gp)
    unlock(&sched.lock)

    // 当前 MP 执行其他任务
    schedule()
}

runtime.Goexit

终止当前任务。这与return返回调用堆栈上一级不同，而是直接结束这个任务。

在 Main Goroutine 调用 Goexit，它会等待其他 Gs 结束后才会崩溃。

注意，终止的是G函数执行，而不是MP。

// panic.go

// Goexit terminates the goroutine that calls it. No other goroutine is affected.
// Goexit runs all deferred calls before terminating the goroutine. Because Goexit
// is not a panic, any recover calls in those deferred functions will return nil.
//
// Calling Goexit from the main goroutine terminates that goroutine
// without func main returning. Since func main has not returned,
// the program continues execution of other goroutines.
// If all other goroutines exit, the program crashes.

func Goexit() {
    
    // panic, defer ...
    
    goexit1()
}

// proc.go

// Finishes execution of the current goroutine.
func goexit1() {
    mcall(goexit0)
}

// goexit continuation on g0.
func goexit0(gp *g) {

    // G 任务结束，清理后放回复用链表。
    casgstatus(gp, _Grunning, _Gdead)
    dropg()
    gfput(_p_, gp)
    
    // 当前 MP 继续执行其他任务。
    schedule()
}

Go1.18调度器-内核调用

2022-04-18T00:00:00+00:00

运行时(runtime)不能使用用户栈(G.stack)，须切回到M.g0。为此用汇编实现了专门的调用函数。

有关汇编相关内容，参考《语言规范，进阶-混合编程》。

正常情况下，不会调整g0.sched设置。保持mstart1设置的初始化状态。以此开始执行，复用栈内存。

因此，每次切换到g0都从第二栈帧开始，无须清理调用堆栈。一旦出错，就回到mstart0内调用mexit终止。

mcall

保存当前G执行状态，切换到g0执行特定函数。由于函数不返回，所以mcall不负责切回G。

// asm_amd64.s

// func mcall(fn func(*g))
// Switch to m->g0's stack, call fn(g).

// Fn must never return. It should gogo(&g->sched)
// to keep running g.

TEXT runtime·mcall<ABIInternal>(SB), NOSPLIT, $0-8
    
    // 参数
    MOVQ    AX, DX                              // DX = fn

    // 保存状态（g.sched）。
    // g状态保存到g.sched
    MOVQ    0(SP), BX
    MOVQ    BX, (g_sched+gobuf_pc)(R14)         // BX ==> g.sched.pc
    LEAQ    fn+0(FP), BX                        // g.sp ==> BX
    MOVQ    BX, (g_sched+gobuf_sp)(R14)         // BX ==> g.sp ==> save ==> g.sched.sp
    MOVQ    BP, (g_sched+gobuf_bp)(R14)         // BP ==> g.bp ==> save ==> g.sched.bp

    MOVQ    g_m(R14), BX                        // BX = g.m
    MOVQ    m_g0(BX), SI                        // SI = g.m.g0  ==> G0
    
    CMPQ    SI, R14                             // if g == m->g0 call badmcall  // SI ==> G0  R14 ==> g
    JNE     goodm
    JMP     runtime·badmcall(SB)
    
    goodm:

    // 保存当前 g，作为后续调用参数。
    MOVQ    R14, AX                            // AX (and arg 0) = g; g保存到AX
    MOVQ    SI, R14                            // g.m.g0  ==> R14 ==> G0

    // 恢复 g0 栈。
    get_tls(CX)                                // MOVQ (TLS), CX                    // Set G in TLS, 
    MOVQ    R14, g(CX)                         // MOVQ R14(G0) 0(CX)(TLS*1)
    MOVQ    (g_sched+gobuf_sp)(R14), SP        // sp = g0.sched.sp
    
    // 调用目标函数。
    PUSHQ   AX                                  // fn.arg = g; 将g状态AX保存到stack
    MOVQ    0(DX), R12                          // [DX] ==> 待执行的特殊函数
    CALL    R12              // fn(g            // G0执行特定函数
    
    POPQ    AX
    JMP     runtime·badmcall2(SB)
    RET

提示：get_tls将G指针存入指定寄存器。

systemstack

切换到M.g0执行特定函数，然后恢复G执行。

// asm_amd64.s

// func systemstack(fn func())
TEXT runtime·systemstack(SB), NOSPLIT, $0-8
    
    // 参数。
    MOVQ    fn+0(FP), DI        // DI = fn
    
    // 当前 G、M。
    get_tls(CX)
    MOVQ    g(CX), AX           // AX = g
    MOVQ    g_m(AX), BX         // BX = m

    CMPQ    AX, m_gsignal(BX)
    JEQ     noswitch

    // 获取 M.g0。
    MOVQ    m_g0(BX), DX        // DX = g0
    CMPQ    AX, DX
    JEQ     noswitch

    CMPQ    AX, m_curg(BX)
    JNE     bad

    // 保存当前 g 状态（g.sched）。
    CALL    gosave_systemstack_switch<>(SB)

    // 切换到 g0 栈。
    MOVQ    DX, g(CX)
    MOVQ    DX, R14 // set the g register
    MOVQ    (g_sched+gobuf_sp)(DX), BX
    MOVQ    BX, SP

    // 调用目标函数。
    MOVQ    DI, DX
    MOVQ    0(DI), DI
    CALL    DI

    // 切换回 g。
    get_tls(CX)
    MOVQ    g(CX), AX
    MOVQ    g_m(AX), BX       // M
    MOVQ    m_curg(BX), AX    // M.curg !!!
    MOVQ    AX, g(CX)
    MOVQ    (g_sched+gobuf_sp)(AX), SP
    MOVQ    $0, (g_sched+gobuf_sp)(AX)
    RET

// Save state of caller into g->sched,
TEXT gosave_systemstack_switch<>(SB),NOSPLIT,$0
    MOVQ    $runtime·systemstack_switch(SB), R9
    MOVQ    R9, (g_sched+gobuf_pc)(R14)
    LEAQ    8(SP), R9
    MOVQ    R9, (g_sched+gobuf_sp)(R14)
    MOVQ    $0, (g_sched+gobuf_ret)(R14)
    MOVQ    BP, (g_sched+gobuf_bp)(R14)
    // Assert ctxt is zero. See func save.
    MOVQ    (g_sched+gobuf_ctxt)(R14), R9
    TESTQ   R9, R9
    JZ      2(PC)
    CAL     runtime·abort(SB)
    RET

gogo

跳转到指定的G.sched.pc执行。

因为 gogo 由 schedule/g0调用，无需保存G.stack状态。

仅 goexit0 出错时，才执行 gogo(g0.sched)。

// asm_amd64.s

// func gogo(buf *gobuf)
// restore state from Gobuf; longjmp

TEXT runtime·gogo(SB), NOSPLIT, $0-8
    MOVQ    +0(FP), BX          // gobuf
    MOVQ    uf_g(BX), DX        // gobuf.g
    MOVQ    X), CX              // make sure g != nil
    JMP     gogo<>(SB)

TEXT gogo<>(SB), NOSPLIT, $0
    get_tls(CX)
    MOVQ    DX, g(CX)
    MOVQ    DX, R14             // set the g register
    
    // 切换到 G.stack。
    MOVQ    gobuf_sp(BX), SP    // restore SP
    MOVQ    gobuf_ret(BX), AX
    MOVQ    gobuf_ctxt(BX), DX
    MOVQ    gobuf_bp(BX), BP
    
    MOVQ    $0, gobuf_sp(BX)    // clear to help garbage collector
    MOVQ    $0, gobuf_ret(BX)
    MOVQ    $0, gobuf_ctxt(BX)
    MOVQ    $0, gobuf_bp(BX)
    
    // 跳转执行 G.fn。
    // 不会保存 gogo.PC，所以 G.fn RET 指向 goexit。
    MOVQ    gobuf_pc(BX), BX
    JMP     BX

Go1.18调度器-任务调度

2022-04-12T00:00:00+00:00

调度

调度函数除在各级队列查找任务外，还要处理垃圾回收、锁定等情况。

调度器-schedule

// proc.go

// One round of scheduler: find a runnable goroutine and execute it.
// Never returns.

func schedule() {
    _g_ := getg()
    
    // 检查当前 M 是否被特定 G 锁定。
    // 交出 P，休眠 M，直到其他人发现锁定任务后唤醒执行。    
    if _g_.m.lockedg != 0 {
        // 将当前的 M 和 P 解绑
        stoplockedm()
        execute(_g_.m.lockedg.ptr(), false) // Never returns.
    }
    
top:
    
    pp := _g_.m.p.ptr()
    pp.preempt = false      // 设置抢占位；不抢占
    
    // GC等待被执行
    // STW 标记。
    if sched.gcwaiting != 0 {
        gcstopm()
        goto top
    }
    
    // 执行安全函数，比如 forEachP。
    if pp.runSafePointFn != 0 {
        runSafePointFn()
    }

    // 检查并执行定时器。
    checkTimers(pp, 0)
    
    var gp *g
    var inheritTime bool

    // 启动垃圾回收任务。
    if gp == nil && gcBlackenEnabled != 0 {
        gp = gcController.findRunnableGCWorker(_g_.m.p.ptr())
        if gp != nil {
            tryWakeP = true
        }
    }
    
    // 每隔 60 次，尝试从全局队列提取任务，以确保公平。
    if gp == nil {
        
        // Check the global runnable queue once in a while to ensure fairness.
        // Otherwise two goroutines can completely occupy the local runqueue
        // by constantly respawning each other.
        
        if _g_.m.p.ptr().schedtick%61 == 0 && sched.runqsize > 0 {
            lock(&sched.lock)
            gp = globrunqget(_g_.m.p.ptr(), 1)
            unlock(&sched.lock)
        }
    }
    
    // 从本地任务队列提取。
    if gp == nil {
        gp, inheritTime = runqget(_g_.m.p.ptr())
        // We can see gp != nil here even if the M is spinning,
        // if checkTimers added a local goroutine via goready.
    }
    
    // 从其他可能的地方提取。
    if gp == nil {
        gp, inheritTime = findrunnable() // blocks until work is available
    }
    
    // 找到任务，解除自旋状态。
    if _g_.m.spinning {
        resetspinning()
    }

    // 找到锁定任务，移交 P 给锁定 M 去执行。
    // 自己休眠。一旦被唤醒，则重新开始调度循环。
    if gp.lockedm != 0 {
        
        // Hands off own p to the locked m,
        // then blocks waiting for a new p.
        startlockedm(gp)
        
        goto top
    }
    
    // 执行任务。
    execute(gp, inheritTime)
}

如果返回的是runnext，则 inheritTime = True。表示继承上个任务时间片，不累加执行计数器(P.schedtick)，这会减少对全局队列的检查。

另一方面，sysmon 会比对不同时段计数器，检查是否执行了新任务。以此判断任务执行时间是否超长(10ms)，是否需要抢占调度。

在 GODEBUG=scheddetail=1,schedtrace=1000 输出里可以看到计数器信息

中断

单个G未必在一次调度内结束，因某些原因中断，被重新放回任务队列，等待断点恢复。

MP 切换任务前，会将执行状态(PC、SP)保存到G.sched，其他寄存器数据保存到G.stack。切换本身(G100->G0->G101)，消耗并不大，关键在于如何查找下一个G任务。

阻塞：block、syscall、mutex、channel。
抢占：preempt、sysmon。

锁定

某些G(syscall、cgo)需要与特定M锁定。

一旦锁定，M会休眠直到G出现，并执行。

同理，G只能在锁定M上执行。

这么做是为了维持M的某些特殊状态(比如signal等)

// proc.go

// LockOSThread wires the calling goroutine to its current operating system thread.
// The calling goroutine will always execute in that thread,
// and no other goroutine will execute in it,
// until the calling goroutine has made as many calls to
// UnlockOSThread as to LockOSThread.
// If the calling goroutine exits without unlocking the thread,
// the thread will be terminated.
//
// All init functions are run on the startup thread. Calling LockOSThread
// from an init function will cause the main function to be invoked on
// that thread.
//
// A goroutine should call LockOSThread before calling OS services or
// non-Go library functions that depend on per-thread state.

func LockOSThread() {
    _g_ := getg()
    _g_.m.lockedExt++
    dolockOSThread()
}


func lockOSThread() {
    getg().m.lockedInt++
    dolockOSThread()
}

// dolockOSThread is called by LockOSThread and lockOSThread below
// after they modify m.locked. Do not allow preemption during this call,
// or else the m might be different in this function than in the caller.

func dolockOSThread() {
    _g_ := getg()
    _g_.m.lockedg.set(_g_)  // 存放位置!
    _g_.lockedm.set(_g_.m)
}

在调度函数(scheduler)头部，一旦检查到当前 M 被某个 G 锁定，那么会进入休眠状态，直到目标G出现。

// Stops execution of the current m that is locked to a g until the g is runnable again.
func stoplockedm() {
    _g_ := getg()

    // 交出 P 给其他 M 去执行任务。
    if _g_.m.p != 0 {
        // Schedule another M to run this p.
        _p_ := releasep()
        handoffp(_p_)
    }
    
    // Wait until another thread schedules lockedg again.
    mPark()

    // 被其他 MP 唤醒，关联它转交的 P。
    acquirep(_g_.m.nextp.ptr())
    _g_.m.nextp = 0
}

其他MP找到锁定G，会交出自己的P，唤醒该任务关联M。

// Schedules the locked m to run the locked gp.
func startlockedm(gp *g) {
    _g_ := getg()

    // 该任务锁定的 M。
    mp := gp.lockedm.ptr()
    
    // 转交自己的 P 给锁定 M，并唤醒它。
    _p_ := releasep()
    mp.nextp.set(_p_)
    notewakeup(&mp.park)
    
    // 当前 M 休眠。
    stopm()
}

Q：为什么等待别人转交，而不是锁定M自己找？
A：MP创建锁定G，执行期间可能因为某些原因(syscall)暂停。此时，P被转交给其他人去执行任务，当M醒来时，已失去原P，也就不方便从其他任务队列提取。更何况，该G还可能被转移到全局队列，或被偷窃。如果直接从M.lockedg提取，那么如何处理其存放队列？不如，等它出现后移交。

Go1.18 调度器执行源码剖析

2022-04-11T00:00:00+00:00

执行

execute 切换到G.stack，执行并发函数。

// proc.go

// Schedules gp to run on the current M.
// If inheritTime is true, gp inherits the remaining time in the
// current time slice. Otherwise, it starts a new time slice.
// Never returns.

func execute(gp *g, inheritTime bool) {
    _g_ := getg()

    // 设置任务状态。
    _g_.m.curg = gp
    gp.m = _g_.m
    casgstatus(gp, _Grunnable, _Grunning)
    gp.waitsince = 0
    gp.preempt = false

    /*
        lo           stackguard0                                  hi
        +------------+---------------------------------------------+
        | StackGuard |               stack frames                  |
        +------------+---------------------------------------------+
                                                        <--- SP ----

        StackGuard: 溢出保护区。确保某些操作可以安全分配。
        stckguard0, stackguard1：与SP比较，判断是否溢出，是否需要扩容。
    */
    gp.stackguard0 = gp.stack.lo + _StackGuard
    
    // 累加执行计数器。
    if !inheritTime {
        _g_.m.p.ptr().schedtick++
    }

    // 执行。
    gogo(&gp.sched)
}

函数 gogo 使用汇编实现的执行函数，它会切换到G.stack，并跳转到用户函数。

结束

无论是execute，还是gogo都没有直接回到schedule的意思。那么，如何清理执行现场？比如将dead G放回复用链表。如何继续循环调度呐？

在newproc1设置G.sched的时候，实际保存在pc的是goexit。

// proc.go

func newproc1(fn *funcval, callergp *g, callerpc uintptr) *g {
    
    newg.sched.sp = sp
    newg.stktopsp = sp

    newg.sched.pc = abi.FuncPCABI0(goexit) + sys.PCQuantum // +PCQuantum so that previous instruction is in same function
    newg.sched.g = guintptr(unsafe.Pointer(newg))
    gostartcallfn(&newg.sched, fn)
    
    newg.gopc = callerpc
    newg.startpc = fn.fn

    return newg
}

关键就在于gostartcallfn做了什么。

// stack.go

// adjust Gobuf as if it executed a call to fn
// and then stopped before the first instruction in fn.

func gostartcallfn(gobuf *gobuf, fv *funcval) {
    var fn unsafe.Pointer
    if fv != nil {
        fn = unsafe.Pointer(fv.fn)
    } else {
        fn = unsafe.Pointer(abi.FuncPCABIInternal(nilfunc))
    }
    gostartcall(gobuf, fn, unsafe.Pointer(fv))
}

// sys_x86.go

// adjust Gobuf as if it executed a call to fn with context ctxt
// and then stopped before the first instruction in fn.

func gostartcall(buf *gobuf, fn, ctxt unsafe.Pointer) {
    sp := buf.sp
    
       // 将 G.sched.sp 上移一个指针空间。
    sp -= goarch.PtrSize
    
       // 存储 G.sched.pc，也就是预设的 goexit。
    *(*uintptr)(unsafe.Pointer(sp)) = buf.pc
    
       // 调整 G.sched 设置，此时 pc 指向用户函数。
    buf.sp = sp
    buf.pc = uintptr(fn)
    buf.ctxt = ctxt
}

当execute通过gogo切换到G.stack，执行用户函数时，其堆栈如下：

lo  |          |
    | G.fn     |
    +----------+  G.sched.sp
    | goexit   |
hi  +----------+
    |          |

而gogo以JMP调用G.fn，就是说不会将gogo的IP/PC入栈。等G.fn RET执行时，POP PC的结果自然是goexit。该函数以mcall切换回g0栈，完成清理操作，重新回到调度循环。

// asm_amd64.s

// The top-most function running on a goroutine
// returns to goexit+PCQuantum.

TEXT runtime·goexit(SB),NOSPLIT|TOPFRAME,$0-0
    CALL    runtime·goexit1(SB)	// does not return

// proc.go

// Finishes execution of the current goroutine.
func goexit1() {
    mcall(goexit0)
}

// goexit continuation on g0.
func goexit0(gp *g) {
    _g_ := getg()
    _p_ := _g_.m.p.ptr()
    
    // 清理已结束任务状态，并记入 GC。
    casgstatus(gp, _Grunning, _Gdead)
    gcController.addScannableStack(_p_, -int64(gp.stack.hi-gp.stack.lo))
    
    gp.m = nil
    gp.lockedm = 0
    ...
    gp.timer = nil

    // 解除与当前 M 的关联。
    dropg()
    
    // 放回闲置链表（P.gFree），等待复用。
    gfput(_p_, gp)

    // 重回调度函数。
    schedule()
}

KMP字符串查找算法

2022-04-01T00:00:00+00:00

KMP(Knuth-Morris-Pratt)字符串查找算法

KMP算法可在一个字符串s中查找一个词W的出现位置。一个词在不匹配时本身就包含足够的信息来确定下一个匹配可能的开始位置，此算法利用这一特征以避免重新检查先前配对的字符。

这种算法不太容易理解，我也是翻阅了很多资料，才理解。本篇通过一个例子解释什么是KMP。

KMP原理

举例来说，有一个字符串”BBC ABCDAB ABCDABCDABDE”，我想知道，里面是否包含另一个字符串”ABCDABD”？

首先，字符串”BBC ABCDAB ABCDABCDABDE”的第一个字符与搜索词”ABCDABD”的第一个字符，进行比较。因为B与A不匹配，所以搜索词后移一位。

因为B与A不匹配，搜索词再往后移。

就这样，直到字符串有一个字符，与搜索词的第一个字符相同为止。

接着比较字符串和搜索词的下一个字符，还是相同。

直到字符串有一个字符，与搜索词对应的字符不相同为止。

这时，最自然的反应是，将搜索词整个后移一位，再从头逐个比较。这样做虽然可行，但是效率很差，因为你要把”搜索位置”移到已经比较过的位置，重比一遍。

一个基本事实是，当空格与D不匹配时，你其实知道前面六个字符是”ABCDAB”。KMP算法的想法是，设法利用这个已知信息，不要把”搜索位置”移回已经比较过的位置，继续把它向后移，这样就提高了效率。

怎么做到这一点呢？可以针对搜索词，算出一张《部分匹配表》（Partial Match Table）。这张表是如何产生的，后面再介绍，这里只要会用就可以了。

已知空格与D不匹配时，前面六个字符”ABCDAB”是匹配的。

查表可知，最后一个匹配字符B对应的”部分匹配值”为2，因此按照下面的公式算出向后移动的位数：

移动位数 = 已匹配的字符数 - 对应的部分匹配值

因为 6 - 2 等于4，所以将搜索词向后移动4位。

因为空格与Ｃ不匹配，搜索词还要继续往后移。这时，已匹配的字符数为2（”AB”），对应的”部分匹配值”为0。所以，移动位数 = 2 - 0，结果为 2，于是将搜索词向后移2位。

因为空格与A不匹配，继续后移一位。

逐位比较，直到发现C与D不匹配。于是，移动位数 = 6 - 2，继续将搜索词向后移动4位。

逐位比较，直到搜索词的最后一位，发现完全匹配，于是搜索完成。如果还要继续搜索（即找出全部匹配），移动位数 = 7 - 0，再将搜索词向后移动7位，这里就不再重复了。

下面介绍《部分匹配表》是如何产生的。

首先，要了解两个概念：”前缀”和”后缀”。 “前缀”指除了最后一个字符以外，一个字符串的全部头部组合；”后缀”指除了第一个字符以外，一个字符串的全部尾部组合。

“部分匹配值”就是”前缀”和”后缀”的最长的共有元素的长度。以”ABCDABD”为例，
“A”的前缀和后缀都为空集，共有元素的长度为0；
“AB”的前缀为[A]，后缀为[B]，共有元素的长度为0;
“ABC”的前缀为[A, AB]，后缀为[BC, C]，共有元素的长度0；
“ABCD”的前缀为[A, AB, ABC]，后缀为[BCD, CD, D]，共有元素的长度为0；
“ABCDA”的前缀为[A, AB, ABC, ABCD]，后缀为[BCDA, CDA, DA, A]，共有元素为”A”，长度为1；
“ABCDAB”的前缀为[A, AB, ABC, ABCD, ABCDA]，后缀为[BCDAB, CDAB, DAB, AB, B]，共有元素为”AB”，长度为2；
“ABCDABD”的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB]，后缀为[BCDABD, CDABD, DABD, ABD, BD, D]，共有元素的长度为0。
“部分匹配”的实质是，有时候，字符串头部和尾部会有重复。比如，”ABCDAB”之中有两个”AB”，那么它的”部分匹配值”就是2（”AB”的长度）。搜索词移动的时候，第一个”AB”向后移动4位（字符串长度-部分匹配值），就可以来到第二个”AB”的位置。

具体代码

#!/usr/bin/env python
#-*- coding:utf-8 -*-

def kmp_match(s, p):
    match_idx = []
    m = len(s)      # 完整字符串
    n = len(p)      # 需要查询字串
    cur = 0         # 搜索起始指针
    table = partial_table(p)    # 字串匹配表
    while cur <= m-n:           # 只去匹配前m-n个
        for i in range(n):      # 按字串长度进行匹配，如果字串没有匹配上，向后位移
            if s[i+cur] != p[i]:
                cur += max(i - table[i-1], 1)  # 移动位数 = 已匹配的字符数 - 对应的部分匹配值
                break
        else:
            # 匹配上！！！
            match_idx.append(cur)
            cur+=1
    return match_idx


# 部分匹配表
def partial_table(p):
    prefix = set()
    postfix = set()
    ret = [0]   # 第一位无须匹配，从第二位开始
    for i in range(1, len(p)):
        prefix.add(p[:i])                                   # 根据匹配子串长度，依次更新前缀集合
        postfix = {p[j:i+1] for j in range(1, i+1)}         # 每次循环子串，更新后缀集合
        ret.append(len((prefix & postfix or {''}).pop()))   # 每循环一次更新字串同时出现在前缀和后缀的字串，返回其长度   
    return ret


def main():
    s = "ABCDEABC"
    p = "ABC"
    kmp_match(s, p)


if __name__ == "__main__":
    main()

Go1.18 调度器-G队列

2022-03-30T00:00:00+00:00

队列

新建的并发任务(goroutine)被保存在本地队列。

// runtime2.go

type p struct {
    
    // Queue of runnable goroutines. 
    runqhead uint32
    runqtail uint32
    runq     [256]guintptr
    
    // runnext, if non-nil, is a runnable G that was ready'd by
    // the current G and should be run next instead of what's in
    // runq if there's time remaining in the running G's time
    // slice. It will inherit the time left in the current time
    // slice. If a set of goroutines is locked in a
    // communicate-and-wait pattern, this schedules that set as a
    // unit and eliminates the (potentially large) scheduling
    // latency that otherwise arises from adding the ready'd
    // goroutines to the end of the run queue.
    //
    // Note that while other P's may atomically CAS this to zero,
    // only the owner P can CAS it to a valid G.
    runnext guintptr    
}

本地队列runq是一个环状队列，通过累加和取模定位。

其中runq是存储容器，runqhead和runqtail为开始和结束位置。

无需判断回头，两个计数器总是增长，然后 index % len 就可确定在runq上的实际索引。

       0   1   2   3   4   5   
     +---+---+---+---+---+---+
runq | 1 | 0 | 1 | 1 | 1 | 1 |
     +-------+---+---+---+---+

     tail = 13 --> 13 % 6 = 1 --> runq[1]
     head = 8  -->  8 % 6 = 2 --> runq[2]

本地队列容量有限，多余的会转移到全局队列。

// runtime2.go

type schedt struct {
    
    // Global runnable queue.
    runq     gQueue
    runqsize int32    
}

在以高并发为设计目标的前提下，任务应尽可能被“饥饿”MP获取执行，这无关它由谁创建。但考虑到竞争问题，任务需分散存放，以减少锁定。在调度核心schedule函数内，findrunnable会依次检查本地队列、全局队列，乃至去其他P的私有队列偷窃。总之，在有任务的时候，不应该有闲置的MP。

如此，按竞争压力从大到小排列，分别是global/lock、local/lock-free、runnext/cas。而就当前P，runnext是最快也是竞争最小的位置，有助于提升本地执行效率。

本地

将新任务放到runnext，原有的加入runq。如本地队列已满，则主动转移一半任务到全局队列。

// proc.go

func newproc(fn *funcval) {
    newg := newproc1(fn, gp, pc)
    runqput(_p_, newg, true)

    if mainStarted {
        wakep()
    }
}

// proc.go

// runqput tries to put g on the local runnable queue.
// If next is false, runqput adds g to the tail of the runnable queue.
// If next is true, runqput puts g in the _p_.runnext slot.
// If the run queue is full, runnext puts g on the global queue.
// Executed only by the owner P.

func runqput(_p_ *p, gp *g, next bool) {
    
    if randomizeScheduler && next && fastrandn(2) == 0 {
        next = false
    }

       // 放入 runnext，原有的拿出来转移到 runq。
    if next {
    retryNext:
        oldnext := _p_.runnext
        if !_p_.runnext.cas(oldnext, guintptr(unsafe.Pointer(gp))) {
            goto retryNext
        }
        if oldnext == 0 {
            return
        }
        // Kick the old runnext out to the regular run queue.
        gp = oldnext.ptr()
    }

retry:
    
    // 加入本地队列。
    h := atomic.LoadAcq(&_p_.runqhead)
    t := _p_.runqtail    
    if t-h < uint32(len(_p_.runq)) {
        _p_.runq[t%uint32(len(_p_.runq))].set(gp)
        atomic.StoreRel(&_p_.runqtail, t+1)
        return
    }
    
       // 转移任务到全局队列。
    if runqputslow(_p_, gp, h, t) {
        return
    }
    
    // the queue is not full, now the put above must succeed
    goto retry
}

// Put g and a batch of work from local runnable queue on global queue.
// Executed only by the owner P.

func runqputslow(_p_ *p, gp *g, h, t uint32) bool {
    
    // +1 是当前这个引发超量检查的任务 gp。
    var batch [len(_p_.runq)/2 + 1]*g

    // 先从本地队列头部截取一半任务。
    n := t - h
    n = n / 2
    for i := uint32(0); i < n; i++ {
        batch[i] = _p_.runq[(h+i)%uint32(len(_p_.runq))].ptr()
    }
    if !atomic.CasRel(&_p_.runqhead, h, h+n) { 
        return false
    }
    
    // 存入引发超量检查的任务。
    batch[n] = gp

    // 转换为链表。
    for i := uint32(0); i < n; i++ {
        batch[i].schedlink.set(batch[i+1])
    }
    
    var q gQueue
    q.head.set(batch[0])
    q.tail.set(batch[n])

    // 加入全局队列。
    lock(&sched.lock)
    globrunqputbatch(&q, int32(n+1))
    unlock(&sched.lock)
    
    return true
    }

获取任务时，优先从runnext提取，然后是本地队列。考虑到有任务被转移到全局队列，甚至于被其他P偷窃。所以，任务执行次序和创建顺序无关。

// Get g from local runnable queue.

// If inheritTime is true, gp should inherit the remaining time in the
// current time slice. Otherwise, it should start a new time slice.
// Executed only by the owner P.

func runqget(_p_ *p) (gp *g, inheritTime bool) {
    
    // 优先从 runnext 获取。（atomic.cas）
    next := _p_.runnext
    if next != 0 && _p_.runnext.cas(next, 0) {
        return next.ptr(), true
    }

       // 从本地队列获取。（lock-free/atomic.cas）
    for {
        h := atomic.LoadAcq(&_p_.runqhead)
        t := _p_.runqtail
        if t == h {
            return nil, false
        }

        gp := _p_.runq[h%uint32(len(_p_.runq))].ptr()
        if atomic.CasRel(&_p_.runqhead, h, h+1) {
            return gp, false
        }
    }
}

全局

全局队列只是简单的链表。相比本地循环数组队列，性能稍差。

// A gQueue is a dequeue of Gs linked through g.schedlink. A G can only
// be on one gQueue or gList at a time.

type gQueue struct {
    Head guintptr
    Tail guintptr
}

// proc.go

// Put a batch of runnable goroutines on the global runnable queue.
// This clears *batch.

func globrunqputbatch(batch *gQueue, n int32) {
    assertLockHeld(&sched.lock)

    sched.runq.pushBackAll(*batch)
    sched.runqsize += n
    *batch = gQueue{}
}

当然，本地队列为空时，也可以从全局队列倒腾一批过来。

// Try get a batch of G's from the global runnable queue.
// sched.lock must be held.
func globrunqget(_p_ *p, max int32) *g {
    
    assertLockHeld(&sched.lock)

       // 全局队列空。
    if sched.runqsize == 0 {
        return nil
    }

       // 确定数量。
    n := sched.runqsize/gomaxprocs + 1
    if n > sched.runqsize {
        n = sched.runqsize
    }
    if max > 0 && n > max {
        n = max
    }
    if n > int32(len(_p_.runq))/2 {
        n = int32(len(_p_.runq)) / 2
    }

    sched.runqsize -= n

       // 转移到本地队列。
    gp := sched.runq.pop()
    n--
    for ; n > 0; n-- {
        gp1 := sched.runq.pop()
        runqput(_p_, gp1, false)
    }
    
    return gp
}

偷窃

从其他P偷窃任务，涉及runq和runnext，还需考虑timer因素。

// proc.go

// stealWork attempts to steal a runnable goroutine or timer from any P.
func stealWork(now int64) (gp *g, inheritTime bool, rnow, pollUntil int64, newWork bool) {

    // 当前 P，也就是小偷。
    pp := getg().m.p.ptr()

    // 尝试次数。
    const stealTries = 4
    for i := 0; i < stealTries; i++ {
        
        // 如果前几次都没偷到 G，那么最后一次目标是 timer。
        stealTimersOrRunNextG := i == stealTries-1

        // 随机寻找目标。
        for enum := stealOrder.start(fastrand()); !enum.done(); enum.next() {
            p2 := allp[enum.position()]
            
            // 当然不能偷自己。
            if pp == p2 {
                continue
            }
            
            // 偷定时器（直接执行，避免目标来不及处理到期的定时器）
            if stealTimersOrRunNextG && timerpMask.read(enum.position()) {
                
                // 检查并执行到期的定时器。
                tnow, w, ran := checkTimers(p2, now)
                now = tnow
                
                // 如果有定时器被执行。
                if ran {
                    // 定时器函数可能会创建多个新 G。
                    // 注意，定时器虽然是从 p2 偷来的，但是却由当前 pp（小偷）执行，
                    // 如果生成新任务，那也是加入 pp 的本地队列。如此，就没必要再去
                    // p2 私有队列偷窃，改从自身拿一个就好。当然，如果定时器没有生成
                    // 新任务，还得从 p2 身上下手。
                    if gp, inheritTime := runqget(pp); gp != nil {
                        return gp, inheritTime, now, pollUntil, ranTimer
                    }
                    ranTimer = true
                }
            }

            // 那些闲置的 P 没啥可偷的，得从正工作的目标下手。
            if !idlepMask.read(enum.position()) {
                if gp := runqsteal(pp, p2, stealTimersOrRunNextG); gp != nil {
                    return gp, false, now, pollUntil, ranTimer
                }
            }
        }
    }

    // No goroutines found to steal. Regardless, running a timer may have
    // made some goroutine ready that we missed. Indicate the next timer to
    // wait for.
    return nil, false, now, pollUntil, ranTimer
}

// Steal half of elements from local runnable queue of p2
// and put onto local runnable queue of p.
// Returns one of the stolen elements (or nil if failed).

func runqsteal(_p_, p2 *p, stealRunNextG bool) *g {
    
    // 从目标（p2）拿一批任务放到本地（p）。
    t := _p_.runqtail
    n := runqgrab(p2, &_p_.runq, t, stealRunNextG)
    if n == 0 {
        return nil
    }
    
       // 从本地队列尾部提取一个任务，返回。
    n--
    gp := _p_.runq[(t+n)%uint32(len(_p_.runq))].ptr()
    if n == 0 {
        return gp
    }
    
    atomic.StoreRel(&_p_.runqtail, t+n)
    
    return gp
    }

// Grabs a batch of goroutines from _p_'s runnable queue into batch.
// Batch is a ring buffer starting at batchHead.
// Returns number of grabbed goroutines.

func runqgrab(_p_ *p, batch *[256]guintptr, batchHead uint32, stealRunNextG bool) uint32 {
    for {
        h := atomic.LoadAcq(&_p_.runqhead)
        t := atomic.LoadAcq(&_p_.runqtail)

        // 确定数量。
        n := t - h
        n = n - n/2

        // 如果目标本地队列为空，那么尝试偷 runnext 任务。
        if n == 0 {
            if stealRunNextG {
                if next := _p_.runnext; next != 0 {
                    if !_p_.runnext.cas(next, 0) {
                        continue
                    }
                    batch[batchHead%uint32(len(batch))] = next
                    return 1
                }
            }
            return 0
        }

        if n > uint32(len(_p_.runq)/2) {
            continue
        }

        // 批量转移。
        for i := uint32(0); i < n; i++ {
            g := _p_.runq[(h+i)%uint32(len(_p_.runq))]
            batch[(batchHead+i)%uint32(len(batch))] = g
        }

        // 调整被偷窃队列。
        if atomic.CasRel(&_p_.runqhead, h, h+n) {
            return n
        }
    }
}

函数里的n = n-n/2 是个很有意思的算法。

他确保n为奇数时，总是取“一半多”结果，例如(n=3) -> 2; (n=1) -> 1。

这显然比写divmod + if 语句效率高。

Go1.18 调度器-G复用

2022-03-29T00:00:00+00:00

复用

对于执行结束的 dead G 并不会释放，而是缓存在P本地或全局，以待复用。

// runtime2.go

type schedt struct {
    
    // Global cache of dead G's.
    gFree struct {
        lock    mutex
        stack   gList // Gs with stacks
        noStack gList // Gs without stacks
        n       int32
    }    
}

type p struct {
    
    // Available G's (status == Gdead)
    gFree struct {
        gList
        n int32
    }    
}

// runtime2.go, proc.go

// A gList is a list of Gs linked through g.schedlink. A G can only be
// on one gQueue or gList at a time.

type gList struct {
    head guintptr
}

type g struct {
    schedlink    guintptr    
}

type guintptr uintptr

获取

从本地获取。如果为空，则从全局转移一批到本地。

// proc.go

// Get from gfree list.
// If local list is empty, grab a batch from global list.

func gfget(_p_ *p) *g {

retry:
    // 本地为空，从全局转移一批后重试。
    if _p_.gFree.empty() && (!sched.gFree.stack.empty() || !sched.gFree.noStack.empty()) {
        lock(&sched.gFree.lock)

        // 直到本地缓存 32 个。
        for _p_.gFree.n < 32 {

            // 优先选择带栈内存的。
            gp := sched.gFree.stack.pop()
            if gp == nil {
                gp = sched.gFree.noStack.pop()
                if gp == nil {
                    break
                }
            }
            
            sched.gFree.n--
            _p_.gFree.push(gp)
            _p_.gFree.n++
        }
        
        unlock(&sched.gFree.lock)
        goto retry
    }
    
    // 从本地提取。
    gp := _p_.gFree.pop()
    if gp == nil {
        return nil
    }
    _p_.gFree.n--
    
    // 分配栈内存。
    if gp.stack.lo == 0 {
        // Stack was deallocated in gfput. Allocate a new one.
        systemstack(func() {
            gp.stack = stackalloc(_FixedStack)
        })
        gp.stackguard0 = gp.stack.lo + _StackGuard
    }
    
    return gp
}

放回

直接放回本地缓存。如果本地过多，则转移到全局，以供其他P使用。

// proc.go

// Put on gfree list.
// If local list is too long, transfer a batch to the global list.

func gfput(_p_ *p, gp *g) {

    // 如果栈扩张过，则释放其内存。
    stksize := gp.stack.hi - gp.stack.lo
    if stksize != _FixedStack {
        // non-standard stack size - free it.
        stackfree(gp.stack)
        gp.stack.lo = 0
        gp.stack.hi = 0
        gp.stackguard0 = 0
    }

    // 放回本地链表。
    _p_.gFree.push(gp)
    _p_.gFree.n++
    
    // 本地数量过多。
    if _p_.gFree.n >= 64 {
        var (
            inc      int32
            stackQ   gQueue
            noStackQ gQueue
        )
        
        // 提取多余的，存为链表并转移到全局。
        for _p_.gFree.n >= 32 {
            gp = _p_.gFree.pop()
            _p_.gFree.n--
            
            // 根据是否有栈内存，安排不同链表。
            if gp.stack.lo == 0 {
                noStackQ.push(gp)
            } else {
                stackQ.push(gp)
            }
            inc++
        }
        
        lock(&sched.gFree.lock)
        
        sched.gFree.noStack.pushAll(noStackQ)
        sched.gFree.stack.pushAll(stackQ)

        sched.gFree.n += inc
        unlock(&sched.gFree.lock)
    }
}

Go1.18 调度器-G任务

2022-03-24T00:00:00+00:00

编译器将 go func() 翻译为newproc调用，目标函数及其参数被打包成funcval结构对象。

// main.go

func test(x int, p *int) {
    println(x, *p)
}

func main() {
    x := 111
    y := 222

    go test(x, &y)
}

$ go build -gcflags "-S"

"".main STEXT size=139 args=0x0 locals=0x20 funcid=0x0 align=0x0	

    # 逃逸到堆上的y
    LEAQ	type.int(SB), AX
    CALL	runtime.newobject(SB)
    AX, "".&y+16(SP)
    $222, (AX)

    # 打包目标函数和参数
    LEAQ	type.noalg.struct { F uintptr; ""..autotmp_2 int; ""..autotmp_3 *int }(SB), AX
    CALL	runtime.newobject(SB)

    # funcval.fn --> func1 --> test
    LEAQ	"".main.func1(SB), CX
    MOVQ	CX, (AX)

    # funcval.x
    MOVQ	$111, 8(AX)
    
    # funcval.p -> &y
    MOVQ	"".&y+16(SP), CX
    MOVQ	CX, 16(AX)

    CALL runtime.newproc(SB)


"".main.func1 STEXT size=76 args=0x0 locals=0x18 funcid=0x15 align=0x0
    MOVQ	16(DX), BX
    MOVQ	8(DX), AX
    CALL	"".test(SB)


"".test STEXT size=113 args=0x10 locals=0x20 funcid=0x0 align=0x0
    # x
    MOVQ	AX, ""..autotmp_3+16(SP)

    # *p
    MOVQ	(BX), CX
    MOVQ	CX, ""..autotmp_4+8(SP)

    MOVQ	""..autotmp_3+16(SP), AX
    CALL	runtime.printint(SB)
	
    MOVQ	""..autotmp_4+8(SP), AX
    CALL	runtime.printint(SB)

了解打包流程后，如下代码就好理解了。

// runtime2.go

type funcval struct {
    fn uintptr
    // variable-size, fn-specific data here
}

// proc.go

// Create a new g running fn.
// Put it on the queue of g's waiting to run.
// The compiler turns a go statement into a call to this.

func newproc(fn *funcval) {
    gp := getg()
    
    // 获取 go func 下一条指令位置。
    pc := getcallerpc()
    
    systemstack(func() {
        newg := newproc1(fn, gp, pc)

        // 获取的g放入本地队列。
        _p_ := getg().m.p.ptr()
        runqput(_p_, newg, true)        

        // 如果 main G 启动完毕，则唤醒其他MP执行任务
        if mainStarted {
            wakep()
        }
    })
}

取一个G对象(复用或新建)，初始化自带栈，并在sched等字段内记录执行相关信息。

// runtime2.go

type g struct {
    stack           stack
    sched           gobuf
    gopc            uintptr         // pc of go statement that created this goroutine
    startpc         uintptr         // pc of goroutine function
}

// proc.go

// Create a new g in state _Grunnable, starting at fn. callerpc is the
// address of the go statement that created this. The caller is responsible
// for adding the new g to the scheduler.
func newproc1(fn *funcval, callergp *g, callerpc uintptr) *g {
    
    // 获取可复用 G, 或新建
    newg := gfget(_p_)
    if newg == nil {
        // 本地队列和全局队列都为空，则创建新 G
        newg = malg(_StackMin)
        casgstatus(newg, _Gidle, _Gdead)
        allgadd(newg)
    }

    // 初始化任务数据
    totalSize := uintptr(4*goarch.PtrSize + sys.MinFrameSize) // extra space in case of reads slightly beyond frame
    totalSize = alignUp(totalSize, sys.StackAlign)
    sp := newg.stack.hi - totalSize

    memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))
    newg.sched.sp = sp
    newg.stktopsp = sp
    newg.sched.pc = abi.FuncPCABI0(goexit) + sys.PCQuantum // +PCQuantum so that previous instruction is in same function
    newg.sched.g = guintptr(unsafe.Pointer(newg))
    
    gostartcallfn(&newg.sched, fn)
    newg.gopc = callerpc
    newg.startpc = fn.fn

    // 修改状态，并记录 GC
    casgstatus(newg, _Gdead, _Grunnable)
    gcController.addScannableStack(_p_, int64(newg.stack.hi-newg.stack.lo))

    return newg
}

编号

在sched里有个计数器，用于分配G.goid编号。

// runtime2.go

type schedt struct {
    goidgen   uint64
}

考虑到多个P共同使用，所以每次都提取一段“缓存”到本地。

// proc.go

// Number of goroutine ids to grab from sched.goidgen to local per-P cache at once.
// 16 seems to provide enough amortization, but other than that it's mostly arbitrary number.
_GoidCacheBatch = 16

// runtime2.go

type p struct {
    // Cache of goroutine ids, amortizes accesses to runtime·sched.goidgen.
    goidcache    uint64
    goidcacheend uint64
}

type g struct {
    goid         int64
}

在newproc1里，通过判断本地计数是否达到尾部(goidcacheend)来决定是否新取一批过来。

就是简单的将 sched.goidgen + 16，表示取走 16 个连续号。这样就保证了多个P之间G.id的唯一性。

注意，G对象复用时，会重新赋予id。通过编号，我们大概能判断进程里共计创建过多个任务。

// proc.go

func newproc1(fn *funcval, callergp *g, callerpc uintptr) *g {

    // 复用或新建
    newg := gfget(_p_)
    if newg == nil {
        newg = malg(_StackMin)
        casgstatus(newg, _Gidle, _Gdead)
        allgadd(newg)
    }

    // 初始化相关属性...
    newg.startpc = fn.fn

    casgstatus(newg, _Gdead, _Grunnable)
    gcController.addScannableStack(_p_, int64(newg.stack.hi-newg.stack.lo))

    // 编号缓存不足，从 sched 取一段回来。
    if _p_.goidcache == _p_.goidcacheend {

        // Sched.goidgen is the last allocated id,
        // this batch must be [sched.goidgen+1, sched.goidgen+GoidCacheBatch].
        // At startup sched.goidgen=0, so main goroutine receives goid=1.
        
        _p_.goidcache = atomic.Xadd64(&sched.goidgen, _GoidCacheBatch)
        _p_.goidcache -= _GoidCacheBatch - 1
        _p_.goidcacheend = _p_.goidcache + _GoidCacheBatch
    }
    
    / 赋予新编号。
    newg.goid = int64(_p_.goidcache)
    _p_.goidcache++

    return newg
}

Go1.18 泛型

2022-03-22T00:00:00+00:00

generic(泛型)

为了支持泛型函数，Go1.18 开始支持泛型参数，泛型参数的操作必须是所有参数类型能够支持的。

约束(constraint)

仅允许使用该约束范围内进行操作泛型。目前Go支持以下泛型约束：

any：无约束
comparable：约定范围是泛型能够使用==和!=进行比较的类型
custom：自定义约束，Eg: V int 64 | float64，表示V类型可以是int64或float64

any

any 其实是 interface{} 的别名，行为和interface{}相同，让人看起来很舒服，以后可以不再使用interface{}。

// ForEach使用any配合类型参数，可以让ForEach()接收任何类型的参数

package main

import (
    "fmt"
)

func ForEach[T any](list []T, action func(T)) {
    for _, item := range list {
        action(item)
    }
}

func main() {
    ForEach([]string{"Hello", "world"}, func(s string) {
        fmt.Println(s)
    })
}

如果不使用类型参数，可以使用强制类型转换：

// any类型的参数强制转换成string类型
package main

import (
    "fmt"
)

func ForEachWithAny(list []any, action func(any)) {
   for _, item := range list {
      action(item)
   }
}

func main() {
    ForEachWithAny([]any{"Hello", "World"}, func(s any) {
        fmt.Printf(s.(string))
    })
}

comparable

comparable属于go预先声明的(buildin.go)，它表示任何能够使用==和!=进行比较的类型。使用该约束条件的泛型必须支持该操作，否则报错。

package main

import (
    "fmt"
)

func SumIntsOrFloats[K comparable, V int64 | float64](m map[K]V) V {
    var s V
    
    for _, v := range m {
        s += v
    }
    return s
}

func main() {
    ints := map[string]int64{
        "first":  34,
        "second": 12,
    }
    
    floats := map[string]float64{
        "first":  35.98,
        "second": 26.99,
    }
    
    fmt.Printf("sum: %v and %v\n", SumIntsOrFloats[string, int64](ints), SumIntsOrFloats[string, float64](floats))

    // 可忽略类型参数，编译器可以自动推断
    // fmt.Printf("sum: %v and %v\n", SumIntsOrFloats(ints), SumIntsOrFloats(floats))
}

custom

自定义约束，可以根据实际需要进行定义约束条件。

package main

import (
    "fmt"
)

type Number interface {
    int64 | float64
}

func SumNumbers[K comparable, V Number](m map[K]V) V {
    var s V
    for _, v := range m {
        s += v
    }
    return s
}

func main() {
    ints := map[string]int64{
        "first":  34,
        "second": 12,
    }
    
    floats := map[string]float64{
        "first":  35.98,
        "second": 26.99,
    }
    
    fmt.Printf("sum: %v and %v\n", SumNumbers[string, int64](ints), SumNumbers[string, float64](floats))
}

衍生类型(`~`)

如下实例，类型ID和类型int64是不同的，因此无法使用上面定义的SumNumbers()。Go1.18提供了操作符~表示衍生类型，这样可以使用~int64表示int64和它任何衍生类型。

package main

import (
    "fmt"
)

type ID int64

type NumberDerived interface {
   ~int64 | ~float64
}

func SumNumbersDerived[K comparable, V NumberDerived](m map[K]V) V {
   var s V
   for _, v := range m {
      s += v
   }
   return s
}


func main() {
    ids := map[string]ID{
        "first":  ID(34),
        "second": ID(12),
    }
    fmt.Printf("sum: %v\n", SumNumbersDerived(ids))
}

源码剖析

实例代码

package main

import (
    "errors"
    "fmt"
)

func indexOf[T comparable](s []T, x T) (int, error) {
    for i, v := range s {
        if v == x {
            return i, nil
        }
    }
    return 0, errors.New("not found")
}

func main() {
    var s []string = []string{"apple", "banana", "pear"}
    i, err := indexOf(s, "banana")
    fmt.Println(i, err)

    var it []int = []int{1, 2, 3}
    n, err := indexOf(it, 1)
    fmt.Println(n, err)
}

Go 泛型实现

generic 在很多静态编译型语言都存在该能力。generic 发生在编译期，对Runtime性能没有影响。Go 1.18中通过字典和GCShape模板的泛型实现。在模板法(GCShape)和字典法(.dict)中间取一个中庸。

GCShape

GCShape是一组类型，实例化时指定类型参数就可以共享通用函数(方法)签名。GCShape类型是我们在实例化实现中使用的特定类型，用于填充gcshape分组的所有类型。

字典(`.dict`)

泛型的编译器实现主要关注创建泛型函数和方法的实例化，这些函数和方法将使用具有具体类型的参数执行。

为了避免调用泛型函数(方法)时，根据不同函数参数生成不同的函数签名。并且为了实现简单(和性能)，没必要每次调用泛型函数时生成一个函数签名，我们可以在具有相同GCShape的类型参数之间共享泛型函数的签名。

模板(`go.shape.{type}_{number}`)

使用泛型编程，编译器编译时根据实际类型对函数泛型重命名(go.shape.string_0)。使用模板方法的优势是，所有工作都在编译器完成，对运行时(runtime)没有性能影响。但带来的问题是，如果代码中存在大量函数(方法)调用，则会产生大量的函数签名，使编译后的ELF文件.TEXT过大。

针对.text过大问题，所以Go并未完全采用模板法，而是采用模板法和字典法的一种折中方案。

代码片段

func main() {
    var s []string = []string{"apple", "banana", "pear"}
    i, err := indexOf(s, "banana")
    fmt.Println(i, err)
}

; 被调函数indexOf，根据实参类型，将泛型进行替换为实际类型。
; 同时修改indexOf函数签名为 indexOf[go.shape.string_0] 
=> 0x000000000047e150 <+240>:	movups XMMWORD PTR [rsp+0xb0],xmm15
   0x000000000047e159 <+249>:	mov    rbx,QWORD PTR [rsp+0xe0]
   0x000000000047e161 <+257>:	mov    rcx,QWORD PTR [rsp+0xe8]
   0x000000000047e169 <+265>:	mov    rdi,QWORD PTR [rsp+0xf0]
   0x000000000047e171 <+273>:	lea    rax,[rip+0x34a88]        # 0x4b2c00 <main..dict.indexOf[string]>
   0x000000000047e178 <+280>:	lea    rsi,[rip+0x16ddd]        # 0x494f5c
   0x000000000047e17f <+287>:	mov    r8d,0x6
   0x000000000047e185 <+293>:	call   0x47e4e0 <main.indexOf[go.shape.string_0]>

; 变量s类型 --> slice --> []string
(gdb) ptype s
type = struct []string {
    string *array;
    int len;
    int cap;
}

; string结构 --> |ptr|len| --> 底层数组
; bx寄存器存储 字符串指针
(gdb) x/6xg $rbx
0xc000064f40:	0x0000000000494d87	0x0000000000000005      ; s[0]  -> apple
0xc000064f50:	0x0000000000494f5c	0x0000000000000006      ; s[1]  -> banana
0xc000064f60:	0x0000000000494cc7	0x0000000000000004      ; s[2]  -> pear

; apple -> 5byte
(gdb) x/5xb 0x0000000000494d87
0x494d87:	0x61	0x70	0x70	0x6c	0x65

; banana -> 6byte
(gdb) x/6xb 0x0000000000494f5c
0x494f5c:	0x62	0x61	0x6e	0x61	0x6e	0x61

; pear -> 4byte
(gdb) x/4xb 0xc000064f60
0xc000064f60:	0xc7	0x4c	0x49	0x00

; 1. go.shape.string_0 -> 根据参数生成的函数签名模板，如果再有相同的请求
; 2. .dict -> 通过查询.dict字典，获取函数参数类型
; 3. s, x 为参数列表
; 4. ~r0, ~r1 为函数返回值，因为Go1.17后，参数和返回值通过寄存器进行数据传递
main.indexOf[go.shape.string_0] (.dict=4926464, s=..., x=..., ~r0=10, ~r1=...) at /root/go/david/main.go:8

rust 切片

2021-08-02T00:00:00+00:00

切片(slice,[T])引用序列对象片段，没有所有权。动态尺寸类型(DST，dynamically sized type)，无法直接使用，只能通过指针(&[T])进行。

A type with a size that is known only at run-time is called a dynamically sized type (DST) or, informally, an unsized type. Slices and trait objects are two examples of DSTs.

数组：[T; size] vs &[T]切片

因为[T]长度在编译期间无法确认，所以只能通过固定长度的“指针”定义。

所谓&[T]切片指针，本质上是一个结构体，包含指针和长度信息。

fn main() {
    let v = [1, 2, 3];              // array
    // let s: &[i32] = &v[...];     // slice

    let s = v[..];                  // 不支持直接操作切片,需要通过slice pointer进行操作
       //  ^ doesn't have a size known at compile-time
       // note: all local variables must have a statically known size
}

当操作动态尺寸(DST)类型数据时，只能通过指针进行操作，不能直接操作。

数据结构示意图

// 反汇编

s = &[i32] {
  data_ptr: 0x7fffffffe394,
  length: 3
}

(gdb) x/3xw 0x7fffffffe394
0x7fffffffe394:	0x00000001	0x00000002	0x00000003

   &[T]
  +=====+             +=======//=======+
  | ptr | ----------> | data ...       |
  +-----+             +=======//=======+
  | len |
  +=====+

struct &[T] {
    data_ptr: *mut T,
    length: usize,
}

切片类型

&T: shared slice。
&mut [T]: mutable slice，通过指针修改slice元素
Box<[T]>: boxed slice，装箱堆上分配

构造

从已有序列对象，以起始和结束索引进行构造。

[..]: [0, len -1]
[0..2]: [0, 2]
[0..=2]: [0, 2]
[3..]: [3, len-1]
[..3]: [0, 3]
[..=3]: [0, 3]

&v[..]的实际操作是&(v[..])。

[T]是切片；&[T]是通过”指针”访问切片。

fn main() {
    let v = vec![0, 1, 2, 3];

    let s = &v[..];                     // [0, 3]
    assert_eq!([0, 1, 2, 3], s);

    let s = &v[0..2];                   // [0, 2)
    assert_eq!([0, 1], s);

    let s = &v[0..=2];                  // [0, 2]
    assert_eq!([0, 1, 2], s);

    let s = &v[..2];                    // [0, 2)
    assert_eq!([0, 1], s);

    lset s = &v[..=2];                  // [0, 2]
    assert_eq!([0, 1, 2], s);

    let s = &v[2..];
    assert_eq!([2, 3], s);              // [2, 3]
}

类型转换

注意区别数组引用和切片，虽然可以强制转换。

fn type_of<T>(_: &T) -> &'static str {
    std::any::type_name::<T>()
}

fn main() {
    let s = &[1, 2, 3];
    assert_eq!("&[i32; 3]", type_of(&s));       // array reference

    let s = &[1, 2, 3][..];
    assert_eq!("&[i32]", type_of(&s));          // slice

    let s: &[i32] = &[1, 2, 3];                 // convert
    assert_eq!("&[i32]", type_of(&s));          // slice

    let s = &["one", "two"][..];                // slice
    assert_eq!("&[&str]", type_of(&s));
}

use std::convert::TryFrom;

fn type_of<T>(_: &T) -> &'static str {
    std::any::type_name::<T>()
}

fn main() {
    let a = &[1, 2, 3];
    let s = &a[..];

    assert_eq!("&[i32; 3]", type_of(&a));       // array
    assert_eq!("&[i32]", type_of(&s));          // slice

    // === convert =====================================

    let s2: &[i32] = &[1, 2, 3];                // array2slice
    assert_eq!("&[i32]", type_of(&s));

    let a2 = <&[i32; 3]>::try_from(s2);         // slice2array
    assert_eq!("&[i32; 3]", type_of(&a2.unwrap()));

    println!("{:?}", &a2);
}

操作

通过可变切片间接修改数据源。

⚠️ 切片索引与数据源索引未必一致。

fn main() {
    let mut v = vec![0, 1, 2, 3];
    
    let s = &mut v[2..];
    s[0] += 100;                        // 使用slice的切片索引修改原vec数据

    assert_eq!(v, [0, 1, 102, 3]);
}

反汇编:

s = &mut [i32] {                                            // slice
  data_ptr: 0x55555559f9d8,
  length: 2
}

v = alloc::vec::Vec<i32, alloc::alloc::Global> {            // vec
  buf: alloc::raw_vec::RawVec<i32, alloc::alloc::Global> {
    ptr: core::ptr::unique::Unique<i32> {
      pointer: 0x55555559f9d0,
      _marker: core::marker::PhantomData<i32>
    },
    cap: 4,
    alloc: alloc::alloc::Global
  },
  len: 4
}

遍历(修改)切片

fn main() {
    let s = &mut[1, 2, 3][..];

    for x in s.iter_mut() {
        *x += 100;
    }

    for x in s.iter() {
        println!("{:?}", x);
    }

    println!("{:?}", s);
}

源码实现:

// core/src/slice/mod.rs:723
// 循环遍历获取slice元素

#[inline]
pub fn iter_mut(&mut self) -> IterMut<'_, T> {
    IterMut::new(self)
}

impl<'a, T> IterMut<'a, T> {
    pub(super) fn new(slice: &'a mut [T]) -> Self {
        let ptr = slice.as_mut_ptr();

        unsafe {
            // 检查是否ZST类型
            let end = if mem::size_of::<T>() == 0 {
                // ptr指针不变
                (ptr as *mut u8).wrapping_add(slice.len()) as *mut T
            } else {
                // ptr指针后移
                ptr.add(slice.len())
            };

            // end: 检查迭代器是否完成
            // 依次移动ptr指针位置，直到遍历完成
            Self { ptr: NonNull::new_unchecked(ptr), end, _marker: PhantomData }
        }
    }

    // ...
}

pub fn iter(&self) -> Iter<'_, T> {
    Iter::new(self)
}

impl<'a, T> Iter<'a, T> {
    pub(super) fn new(slice: &'a [T]) -> Self {
        let ptr = slice.as_ptr();
        unsafe {
            let end = if mem::size_of::<T>() == 0 {
                (ptr as *const u8).wrapping_add(slice.len()) as *const T
            } else {
                ptr.add(slice.len())
            };

            Self { ptr: NonNull::new_unchecked(ptr as *mut T), end, _marker: PhantomData }
        }
    }
}

DST: Dynamic Sized Type缩写，动态大小类型。该类型在编译阶段无法确定大小的类型。

ZST: Zero Sized Type缩写，0大小类型。

切片relice操作

fn main() {
    let mut a = [1, 2, 3];

    let s = &mut a[..];
    let s2 = &mut s[1..];

    s2[1] += 100;

    println!("{:?}", s);
    println!("{:?}", a);
}

重新切片受目标slice范围限制，而非底层数组。

fn main() {
    let mut a = [1, 2, 3, 4, 5, 6];

    let s  = &mut a[..3];
    let s2 = &mut s[1..4];
}

$>  cargo r
   Compiling ddd v0.1.0 (/root/rs/ddd)
    Finished dev [unoptimized + debuginfo] target(s) in 2.93s
     Running `/root/rs/ddd/target/debug/ddd`
thread 'main' panicked at 'range end index 4 out of range for slice of length 3', src/main.rs:7:19
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

rust指针

2021-07-30T00:00:00+00:00

很多时候，指针是相对宽泛概念，并非特指原始指针(raw-pointer)。以 引用(reference) 为例，在经过编译器检查后，其身上所承担的职责已经卸去。起码在底层指令层面，和原始指针并无区别。所以说它是指针确实算不得错。

引用和原始指针是独立对象，间接(*p)操作目标。透过指针修改目标值时，无需声明自身为可变(mut)，除非打算改变自己。

fn main() {
    // 要改变的目标，必须是mut。
    let mut x = 100;

    // r: &mut i32，表明目标类型可变。
    let r = &mut x;

    *r+=1;

    // r: &i32, 不可变引用
    let r = &x;
    assert_eq!(*r, 101);
}

原始指针

原始指针分*mut T和*const T两种，分别对应可变和不可变。无论读写都不安全，须自行负责。

*const T : 表示指向类型T的不可变原始指针。它是Copy类型。类似于&T，只是它可以为空值。
*mut T : 一个指向类型T的可变原始指针，它不支持Copy特性(non-Copy)。

fn main() {
    let mut x = 100;

    let r: *mut i32 = &mut x;

    unsafe {
        *r += 1;
        assert_eq!(*r, 101);
    }

    let r: *const i32 = &x;
    assert_eq!(unsafe{ *r }, 101);
}

引用和指针互相转换

可以和引用相互转换。

fn main() {
    let mut x = 100;
    let r = &mut x;

    // 引用转指针必然是安全的。
    let p = r as *mut i32;
    assert_eq!(unsafe{ *p }, x);

    // 指针转回引用就未必安全了。
    let r2: &mut i32 = unsafe{ &mut *p };  // unsafe{ & *p } -> &i32
    *r2 += 1;
    assert_eq!(x, 101);
}

(gdb) info locals
r2 = 0x7fffffffe2a4
p = 0x7fffffffe2a4
r = 0x7fffffffe2a4
x = 101

// 从底层实现来看，引用和指针没有区别
(gdb) x/xg 0x7fffffffe2a4
0x7fffffffe2a4:	0x0000000000000064

(gdb) x/xg 0x7fffffffe2a4
0x7fffffffe2a4:	0x0000000000000064

// *r2 += 1;
(gdb) x/wx 0x7fffffffe2a4
0x7fffffffe2a4:	0x00000065

usize指针转换

可通过usize转换，实现指针运算。也正因为如此，指向无法保证。

use std::mem::size_of_val;

fn main() {
    let mut x = [1, 2, 3, 4];
    let mut p: *mut i32 = &mut x[0]; // 指针自身和目标都可变
    
    unsafe {
        assert_eq!(*p, 1);           // 断言x[0]是否等于1

        p = ((p as usize) + size_of_val(&x[0])) as *mut i32; // p++
        *p += 10;
        assert_eq!(*p, 12);
    }
}

原始指针不参与对象生命周期，也就是说可能成为悬垂指针。

#[derive(Debug)]
struct Data {
    x: i32,
}

impl Drop for Data {
    fn drop(&mut self) {
        println!("Dropping!");
    }
}

fn main() {
    let d = Data{ x: 10 };
    let p = &d as *const Data;

    {
        let _d2 = d;  // move!!!
    }                 // drop!!!

    unsafe {
        println!("{:p}, {:?}", p, *p);
    }
}

$  cargo r
   Compiling ddd v0.1.0 (/root/rs/ddd)
    Finished dev [unoptimized + debuginfo] target(s) in 3.04s
     Running `/root/rs/ddd/target/debug/ddd`
Dropping!
0x7ffdd34821e4, Data { x: 10 }      // 虽然能返回内容，但这只是因为是栈内存未被覆盖的缘故

通过以下反汇编结果，可以看出原始变量d在内层超出{ ... }作用域后，进行了所有权转移，调用 drop进行释放。main函数结束时，超出该作用域没有调用drop函数释放局部变量p，则p成为了悬垂指针。

; /root/rs/ddd/src/main.rs:
  fn main() {
  0x0000555555559250 <+0>: sub    rsp,0xb8

  let d = Data{ x: 10 };
  0x0000555555559257 <+7>: mov    DWORD PTR [rsp+0x34],0xa

  let p = &d as *const Data;
  0x000055555555925f <+15>:  lea    rax,[rsp+0x34]
  0x0000555555559264 <+20>:  mov    QWORD PTR [rsp+0x38],rax

  {
    let _d2 = d;  // move!!!
  0x0000555555559269 <+25>:  mov    ecx,DWORD PTR [rsp+0x34]
  0x000055555555926d <+29>:  mov    DWORD PTR [rsp+0x44],ecx
  }              // drop!!!

  0x0000555555559271 <+33>:  lea    rdi,[rsp+0x44]
  0x0000555555559276 <+38>:  call   0x5555555591f0 <core::ptr::drop_in_place>

  ; ...
  
  0x0000555555559346 <+246>:  lea    rdi,[rsp+0x48]
  0x000055555555934b <+251>:  call   QWORD PTR [rip+0x44a1f]        # 0x55555559dd70

    }
  }
  
  0x0000555555559351 <+257>:  add    rsp,0xb8
  0x0000555555559358 <+264>:  ret
; End of assembler dump.

智能指针

在C++中广泛采用智能指针，主要是由于原始指针非常不安全，开发者在使用它们时需要注意很多细节。不恰当地使用它们，可能会以非常隐蔽的方式导致诸如内存泄漏、引用挂起，以及大型代码库中的双重释放等问题。

智能指针(smart-pointer)是一类数据结构，其行为类似指针，拥有额外的功能。与引用的差别在于，引用 借用(borrow) 目标，而智能指针则 拥有(own) 目标。

智能指针通常实现Deref和Drop特征。Deref重载解引用运算符，让它的操作和引用一致；Drop则负责在离开作用域时清理资源。

Drop

Drop可以自动释放相关值超出作用域后占用的资源。它包含一个 drop 方法，当对象超出作用域时，就会被调用。该方法将 &mut self 作为参数。使用 drop 释放值是以LIFO的方式进行的。也就是说，无论最后构建的是什么，都首先会被释放。

struct Character {
    name: String,
}

impl Drop for Character {
    fn drop(&mut self) {
        println!("{} went away", self.name);
    }
}

fn main() {
    let _steve = Character {
        name: "Steve".into(),
    };

    let _john = Character {
        name: "John".into(),
    };
}

root@8d75790f92f5:~/rs/ddd/src# cargo r
   Compiling ddd v0.1.0 (/root/rs/ddd)
    Finished dev [unoptimized + debuginfo] target(s) in 3.93s
     Running `/root/rs/ddd/target/debug/ddd`

John went away
Steve went away

(gdb) disassemble
Dump of assembler code for function ddd::main:
   0x0000555555559a10 <+0>:	  sub    rsp,0x78
   0x0000555555559a14 <+4>:	  lea    rax,[rip+0x34640]        # 0x55555558e05b
   0x0000555555559a1b <+11>:	lea    rdi,[rsp+0x18]
   0x0000555555559a20 <+16>:	mov    rsi,rax
   0x0000555555559a23 <+19>:	mov    edx,0x5
   0x0000555555559a28 <+24>:	call   0x55555555a610 <<T as core::convert::Into<U>>::into>
   0x0000555555559a2d <+29>:	mov    rax,QWORD PTR [rsp+0x28]
   0x0000555555559a32 <+34>:	mov    QWORD PTR [rsp+0x10],rax
   0x0000555555559a37 <+39>:	movups xmm0,XMMWORD PTR [rsp+0x18]
   0x0000555555559a3c <+44>:	movaps XMMWORD PTR [rsp],xmm0
   0x0000555555559a40 <+48>:	lea    rsi,[rip+0x34619]        # 0x55555558e060
   0x0000555555559a47 <+55>:	lea    rdi,[rsp+0x50]
   0x0000555555559a4c <+60>:	mov    edx,0x4
   0x0000555555559a51 <+65>:	call   0x55555555a610 <<T as core::convert::Into<U>>::into>
   0x0000555555559a56 <+70>:	jmp    0x555555559a58 <ddd::main+72>
   0x0000555555559a58 <+72>:	mov    rax,QWORD PTR [rsp+0x60]
   0x0000555555559a5d <+77>:	mov    QWORD PTR [rsp+0x40],rax
   0x0000555555559a62 <+82>:	movups xmm0,XMMWORD PTR [rsp+0x50]
   0x0000555555559a67 <+87>:	movaps XMMWORD PTR [rsp+0x30],xmm0
   0x0000555555559a6c <+92>:	lea    rdi,[rsp+0x30]
=> 0x0000555555559a71 <+97>:	call   0x555555559370 <core::ptr::drop_in_place>
   0x0000555555559a76 <+102>:	jmp    0x555555559a78 <ddd::main+104>
   0x0000555555559a78 <+104>:	mov    rdi,rsp
   0x0000555555559a7b <+107>:	call   0x555555559370 <core::ptr::drop_in_place>
   0x0000555555559a80 <+112>:	add    rsp,0x78
   0x0000555555559a84 <+116>:	ret
   0x0000555555559a85 <+117>:	mov    rdi,rsp
   0x0000555555559a88 <+120>:	call   0x555555559370 <core::ptr::drop_in_place>
   0x0000555555559a8d <+125>:	mov    rdi,QWORD PTR [rsp+0x68]
   0x0000555555559a92 <+130>:	call   0x555555559050 <_Unwind_Resume@plt>
   0x0000555555559a97 <+135>:	ud2
   0x0000555555559a99 <+137>:	mov    QWORD PTR [rsp+0x68],rax
   0x0000555555559a9e <+142>:	mov    DWORD PTR [rsp+0x70],edx
   0x0000555555559aa2 <+146>:	jmp    0x555555559a85 <ddd::main+117>
End of assembler dump.

(gdb) x/xg $rdi
0x7fffffffe3c0: 0x00005555555a09f0

(gdb) x/4bx 0x00005555555a09f0
0x5555555a09f0: 0x4a  0x6f  0x68  0x6e    ; John

通过反汇编结果，可以看出首先释放的是 john 变量。

Deref 和 DerefMut

为了能够像普通指针一样能够解引用被指向类型的调用方法，智能指针类型通常实现 Deref 特征，这允许用户对这些类型使用 解引用 运算符*。虽然 Deref 只为你提供了只读权限，但是还有 DerefMut，它可以为你提供对底层类型的可变引用。

Deref具有以下类型签名:

// library/core/src/ops/deref.rs

pub trait Deref {
  type Target: ?Sized;
  
  fn deref(&self) -> &Self::Target;
}

它定义了一个名为 deref 的方法，并通过引用获取 self 参数，然后返回对底层类型的不可变引用。与Rust的 deref 强制性特征结合，能够大幅减少开发编写代码的工作量。deref 强制性特征是指类型自动从一种类型的引用转换成另一种类型的其它引用。

use std::ops::Deref;

struct DerefExample<T> {
    value: T
}

impl<T> Deref for DerefExample<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        &self.value
    }
}

fn main() {
    let x = DerefExample { value: 'a' };
    assert_eq!('a', *x);
}

智能指针分类

Box<T>: 在堆上分配值
Rc<T>: 引用计数，可以有多个拥有者
Arc<T>: 用于原子性引用计数(保证多线程的安全性)
Cell<T>: 可以获得多个可变引用
RefCell<T>: 以不可变引用修改值

Box

在堆(heap)上为值分配内存，栈上只是一个指向该内存的指针。

单一所有者。
运行时才知道所需内存大小。
转移所有权时，不想复制数据。

   stack              heap
  +=====+           +=======+
  | ptr | --------> | value |    Box<T>
  +=====+           +=======+

和引用一致的使用方式，没有特殊功能。超出作用域自动释放。

fn main() {
  // 在堆上分配 sizeof(i32) 大小内存，并存储值 5。
  let mut p = Box::new(5);
    
  *p += 1;
  let x: i32 = *p;
    
  assert_eq!(x, 6);
}

0x0000555555559452 <+18>:	mov    eax,0x4
0x0000555555559457 <+23>:	mov    rdi,rax
0x000055555555945a <+26>:	mov    rsi,rax
0x000055555555945d <+29>:	call   0x555555559730 <alloc::alloc::exchange_malloc>
0x0000555555559462 <+34>:	mov    rcx,rax
0x0000555555559465 <+37>:	mov    DWORD PTR [rax],0x5

; let mut p = Box::new(5);
0x000055555555946b <+43>:	mov    QWORD PTR [rsp+0x60],rcx     // p(stack) -> heap -> 0x00000005

(gdb) info locals
x = 6
p = 0x55555559c9d0

(gdb) x/xw 0x55555559c9d0                                       // 在heap上为值分配内存
0x55555559c9d0:	0x00000006

(gdb) info proc mappings
0x55555559c000     0x5555555bd000    0x21000        0x0 [heap]  // heap内存范围

(gdb) disass                                                    // 超出作用域，所有权自动释放
0x0000555555559630 <+496>:	lea    rdi,[rsp+0x60]
0x0000555555559635 <+501>:	call   0x555555559230 <core::ptr::drop_in_place>
0x000055555555963a <+506>:	mov    rdi,QWORD PTR [rsp+0xf0]

Box创建数组类型

fn main() {
    // 以数组实现类 calloc 功能。
    let mut p = Box::new([0i64; 10]);

    p[1] = 10;
    p[2] = 20;

    println!("{:?} {:?}", p[2], p);
}

(gdb) info locals                                               // 数组值被分配在堆上
p = 0x5555555a09d0

(gdb) x/10xg 0x5555555a09d0                                     // heap上值内容
0x5555555a09d0:	0x0000000000000000	0x000000000000000a
0x5555555a09e0:	0x0000000000000014	0x0000000000000000
0x5555555a09f0:	0x0000000000000000	0x0000000000000000
0x5555555a0a00:	0x0000000000000000	0x0000000000000000
0x5555555a0a10:	0x0000000000000000	0x0000000000000000

Box类型所有权

Box类型的所有权语义取决于包装类型。如果基础类型为 Copy，那么 Box实例将成为副本，否则默认情况下发生所有权转移。

fn box_ref<T>(b: T) -> Box<T> {
  // 实例副本
  let a = b;
  Box::new(a)
}

struct Foo(i32);

fn main() {
  let boxed_one = Box::new(Foo(0x64));
  let unboxed_one = *boxed_one;
  box_ref(unboxed_one);
}

; 进程内存地址映射表
(gdb) info proc  mappings
process 1883
Mapped address spaces:

          Start Addr           End Addr       Size     Offset objfile
      0x555555554000     0x555555559000     0x5000        0x0 /root/rs/ddd/target/debug/ddd
      0x555555559000     0x55555558b000    0x32000     0x5000 /root/rs/ddd/target/debug/ddd
      0x55555558b000     0x555555598000     0xd000    0x37000 /root/rs/ddd/target/debug/ddd
      0x555555598000     0x55555559b000     0x3000    0x43000 /root/rs/ddd/target/debug/ddd
      0x55555559b000     0x55555559c000     0x1000    0x46000 /root/rs/ddd/target/debug/ddd
      0x55555559c000     0x5555555bd000    0x21000        0x0 [heap]

      ...

      0x7ffffffde000     0x7ffffffff000    0x21000        0x0 [stack]      

(gdb) info locals
boxed_one = 0x55555559c9d0

; 变量boxed_one指向heap地址: 0x55555559c9d0位置，内容为0x64
(gdb) x/xg 0x55555559c9d0
0x55555559c9d0:	0x0000000000000064

; let unboxed_one = *boxed_one 解引用，获取Foo struct数据
(gdb) info locals
unboxed_one = ddd::Foo (
  100
)

; fn box_ref<T>(b: T) -> Box<T>
(gdb) disassemble
Dump of assembler code for function ddd::box_ref:
=> 0x0000555555559ad0 <+0>:	sub    rsp,0x18
   0x0000555555559ad4 <+4>:	mov    DWORD PTR [rsp+0xc],edi
   0x0000555555559ad8 <+8>:	mov    DWORD PTR [rsp+0x10],edi
   0x0000555555559adc <+12>:	mov    DWORD PTR [rsp+0x14],edi
   0x0000555555559ae0 <+16>:	mov    eax,0x4
   0x0000555555559ae5 <+21>:	mov    DWORD PTR [rsp+0x8],edi
   0x0000555555559ae9 <+25>:	mov    rdi,rax
   0x0000555555559aec <+28>:	mov    rsi,rax
   0x0000555555559aef <+31>:	call   0x555555559660 <alloc::alloc::exchange_malloc>
   0x0000555555559af4 <+36>:	mov    rcx,rax
   0x0000555555559af7 <+39>:	mov    edx,DWORD PTR [rsp+0x8]
   0x0000555555559afb <+43>:	mov    DWORD PTR [rax],edx
   0x0000555555559afd <+45>:	mov    QWORD PTR [rsp],rcx
   0x0000555555559b01 <+49>:	mov    rax,QWORD PTR [rsp]
   0x0000555555559b05 <+53>:	add    rsp,0x18
   0x0000555555559b09 <+57>:	ret
End of assembler dump.

; main函数调用box_ref，通过$rdi寄存器进行传递
; 参数按值传递
(gdb) p/x $edi
$2 = 0x64

; Box::new(a) 返回堆上地址，该内存空间存储具体数据
(gdb) p/x $rcx
$4 = 0x55555559c9f0

(gdb) x/xg 0x55555559c9f0
0x55555559c9f0:	0x0000000000000064

; box_ref返回(rax 堆上地址) 
0x0000555555559b01 <+49>:	mov    rax,QWORD PTR [rsp]
0x0000555555559b05 <+53>:	add    rsp,0x18
0x0000555555559b09 <+57>:	ret

; 所有权释放
0x0000555555559313 <+67>:	call   0x555555559ad0 <ddd::box_ref>
0x0000555555559318 <+72>:	mov    QWORD PTR [rsp],rax
0x000055555555931c <+76>:	jmp    0x55555555931e <ddd::main+78>
0x000055555555931e <+78>:	mov    rax,QWORD PTR [rsp]
0x0000555555559322 <+82>:	mov    QWORD PTR [rsp+0x20],rax
0x0000555555559327 <+87>:	lea    rdi,[rsp+0x20]
0x000055555555932c <+92>:	call   0x5555555591e0 <core::ptr::drop_in_place>
0x0000555555559331 <+97>:	jmp    0x555555559333 <ddd::main+99>

; 释放heap 内存
0x0000555555559333 <+99>:	mov    rdi,QWORD PTR [rsp+0x10]
0x0000555555559338 <+104>:	call   0x555555559d10 <alloc::alloc::box_free>
0x000055555555933d <+109>:	add    rsp,0x48
0x0000555555559341 <+113>:	ret

(gdb) x/xg $rsp+0x10
0x7fffffffe3d0:	0x000055555559c9d0

(gdb) x/xg 0x000055555559c9d0
0x55555559c9d0:	0x0000000000000064

递归类型定义

Box 类型适用于创建递归类型定义。

struct Node {
  data: u32,
  next: Option<Node>
}

fn main() {
  let a = Node { data: 33, next: None };
}

在编译上述代码时，我们得到一下错误提示:

root@8d75790f92f5:~/rs/ddd/src# cargo c
    Checking ddd v0.1.0 (/root/rs/ddd)
error[E0308]: mismatched types
  --> src/main.rs:12:36
   |
12 |     let a = Node { data: 33, next: None };
   |                                    ^^^^ expected struct `Box`, found enum `Option`
   |
   = note: expected struct `Box<Node>`
                found enum `Option<_>`

由于每个数据片段在编译时都需要确定静态的已知尺寸，因此在 Rust 中这是一种不可表示的类型。我们需要让 next 字段具有固定大小，可以通过 next 放在指针后面来实现，因为指针总是具有固定大小。可以使用 Box 类型修改 Node结构体的定义:

struct Node {
  data: u32,
  next: Option<Box<Node>>
}

当定义需要隐藏在不定长结构后面的递归类型时，也可以使用 Box 类型。

引用计数的智能指针

引用计数类型支持某个粒度级别的垃圾回收。在这种方法中，智能指针类型允许用户对包装值进行多次引用。在内部，智能指针使用引用计数器(这里是refcount)来统计自发放的并且活动的引用数量，不过它只是一个整数值。当引用包装的智能指针值的变量超出作用域时，refcount的值就会递减。一旦该对象的所有权引用都消失，refcount 的值也会变成0，之后该值被销毁。这就是引用计数指针常见的工作模式。

Rust提供了两种引用计数指针类型。

Rc<T> : 用于单线程环境
Arc<T>: 用于多线程环境

Rc

引用计数(reference counting)启用多所有权。当引用数为 0 时，进行清理。

堆分配内存，共享所有权
单线程，使用非原子计数
不可变引用，无法修改值
降级获取没有所有权的弱指针(weak pointer)
存在循环引用无法释放的问题(用弱指针解决)

RC底层数据结构:

   stack              heap
  +=====+           +============+
  | ptr | --------> | strong_cnt |    Rc<T>
  +=====+           +------------+
                    | weak_cnt   |
                    +------------+
                    | value      |
                    +============+

// library/alloc/src/rc.rs
struct RcBox<T: ?Sized> {
    strong: Cell<usize>,            // 强引用计数
    weak: Cell<usize>,              // 弱引用计数
    value: T,                       // 值
}

当我们与一个 Rc类型交互时，其内部会发生如下变化。

通过调用 Clone() 获取对 Rc 的一个新共享引用时，Rc会增加其内部引用计数。Rc内部使用 Cell类型处理其引用计数。
当引用超出作用域时，它会对引用计数器执行递减操作。
当所有共享引用计数超出作用域时，refcount 会变成0。此时，Rc上最后一次 drop 调用会执行相关的资源清理工作。

Rc<T> 主要通过两种方式使用:

静态方法 Rc::new 会生成一个新的引用计数器。
clone 方法会增加强引用计数并分发一个新的 Rc<T>。

use std::rc::Rc;

fn main() {
    let rc = Rc::new(5);
    assert_eq!(Rc::strong_count(&rc), 1);

    {
        // 增加引用，计数 +1
        let rc2 = rc.clone();
        assert_eq!(Rc::strong_count(&rc), 2);

        // 解引用
        assert_eq!(*rc2, 5);
    }   // 超出作用域，计数 -1

    assert_eq!(Rc::strong_count(&rc), 1);
}

// heap上存储的是RcBox 数据结构
(gdb) info locals
rc = alloc::rc::Rc<i32> {
  ptr: core::ptr::non_null::NonNull<alloc::rc::RcBox<i32>> {
    pointer: 0x55555559d9d0
  },
  phantom: core::marker::PhantomData<alloc::rc::RcBox<i32>>
}

(gdb) x/3xg 0x55555559d9d0
0x55555559d9d0:	0x0000000000000001	0x0000000000000001
0x55555559d9e0:	0x0000000000000005

// Rc::new执行后，rc引用计数为1
(gdb) x/xg 0x55555559f9d0
0x55555559f9d0:	0x0000000000000001

// rc.clone执行后，rc引用计数自加1, 即2
(gdb) c
Continuing.
Breakpoint 2, ddd::main () at /root/rs/ddd/src/main.rs:13
13	        assert_eq!(Rc::strong_count(&rc), 2);

(gdb) x/xg 0x55555559f9d0
0x55555559f9d0:	0x0000000000000002

// 离开rc2作用域，计数器自减1，即1
(gdb) c
Continuing.
Breakpoint 3, ddd::main () at /root/rs/ddd/src/main.rs:18
18	    assert_eq!(Rc::strong_count(&rc), 1);

(gdb) x/xg 0x55555559f9d0
0x55555559f9d0:	0x0000000000000001

Rc 内部会保留两种引用: 强引用(Rc<T>) 和 弱引用(Weak<T>)。二者都会维护每种类型的引用数量的计数，但是仅在强引用计数值为零时，才会释放该值。这样做的目的是数据结构的实现可能需要多次指向同一事物。

弱引用

use std::rc::{Rc, Weak};

fn main() {
    let wr: Weak<i32>;

    {
        let rc = Rc::new(5);

        // 降级, 生成弱引用
        wr = Rc::downgrade(&rc);

        // 不影响强引用计数
        assert_eq!(Rc::strong_count(&rc), 1);
        assert_eq!(Rc::weak_count(&rc), 1);

        // 弱引用不能保证目标值存活，所以不能直接解引用。
        // 升级成强引用再操作。如已释放，返回None。
        if let Some(rc2) = wr.upgrade() {
            assert_eq!(*rc2, 5);
        } else {
            panic!("upgrade: None");
        }
    }   // Rc drop!!!

    assert_eq!(wr.upgrade(), None);
}

(gdb) info locals
rc = alloc::rc::Rc<i32> {
  ptr: core::ptr::non_null::NonNull<alloc::rc::RcBox<i32>> {
    pointer: 0x5555555a09d0
  },
  phantom: core::marker::PhantomData<alloc::rc::RcBox<i32>>
}

; let rc = Rc::new(5) 引用计数置为1
(gdb) x/xg 0x5555555a09d0
0x5555555a09d0:	0x0000000000000001

; wr = Rc::downgrade(&rc), rc降级为弱引用
; 引用计数不受影响
(gdb) c
Continuing.
Breakpoint 2, ddd::main () at /root/rs/ddd/src/main.rs:15
15	        assert_eq!(Rc::strong_count(&rc), 1);

; 弱引用计数器为1
rc = Rc(strong=1, weak=1) = {
  value = 5,
  strong = 1,
  weak = 1
}

(gdb) x/xg 0x5555555a09d0
0x5555555a09d0:	0x0000000000000001

; wr.upgrade(), wr升级为强引用
; 引用计数自增1
(gdb) c
Continuing.
Breakpoint 3, ddd::main () at /root/rs/ddd/src/main.rs:19
19	            assert_eq!(*rc2, 5);

(gdb) x/xg 0x5555555a09d0
0x5555555a09d0:	0x0000000000000002

; 超出作用域, 引用计数置为0
(gdb) c
Continuing.
Breakpoint 4, ddd::main () at /root/rs/ddd/src/main.rs:25
25	    assert_eq!(wr.upgrade(), None);

(gdb) x/xg 0x5555555a09d0
0x5555555a09d0:	0x0000000000000000

gdb反汇编调试尽可能使用rust-gdb，而不要使用gdb。因为，rust内部封装结构是否构成弱引用必然在实际内存数据上有所体现，但未必暴露给我们这些外部用户。所以gdb调试结果和rust-gdb调试结果有所出入。

循环引用问题

可以使用弱引用打破引用循环。链表可以通过将引用计数分别指向下一个元素和上一个元素的方式维护链接。更好的方法是 对一个方向使用强引用，而对另一个方向使用弱引用 。

单链表实例

use std::rc::Rc;

#[derive(Debug)]
struct LinkedList<T> {
    head: Option<Rc<Node<T>>>
}

#[derive(Debug)]
struct Node<T> {
    next: Option<Rc<Node<T>>>,
    data: T
}

impl<T> LinkedList<T> {
    fn new() -> Self {
        LinkedList { head: None }
    }

    fn append(&self, data: T) -> Self {
        LinkedList {
            head: Some(Rc::new(Node {
                data: data,
                next: self.head.clone()
            }))
        }
    }
}

fn main() {
    let list_of_nums = LinkedList::new().append(1).append(2);
    println!("numbs: {:?}", list_of_nums);

    let list_of_strs = LinkedList::new().append("foo").append("bar");
    println!("strs: {:?}", list_of_strs);
}

反汇编单向链表:

; list_of_nums
(gdb) info locals
list_of_nums = ddd::LinkedList<i32> {
  head: core::option::Option<alloc::rc::Rc<ddd::Node<i32>>>::Some(alloc::rc::Rc<ddd::Node<i32>> {
      ptr: core::ptr::non_null::NonNull<alloc::rc::RcBox<ddd::Node<i32>>> {
        pointer: 0x5555555a29d0
      },
      phantom: core::marker::PhantomData<alloc::rc::RcBox<ddd::Node<i32>>>
    })
}
(gdb) x/4xg 0x5555555a29d0
0x5555555a29d0:	0x0000000000000001	0x0000000000000001
0x5555555a29e0:	0x00005555555a2910	0x0000000000000002    ; 0x00005555555a2910 下一个链表节点地址 

(gdb) x/4xg 0x00005555555a2910
0x5555555a2910:	0x0000000000000001	0x0000000000000001
0x5555555a2920:	0x0000000000000000	0x0000000000000001

; list_of_strs
(gdb) info locals
list_of_strs = ddd::LinkedList<&str> {
  head: core::option::Option<alloc::rc::Rc<ddd::Node<&str>>>::Some(alloc::rc::Rc<ddd::Node<&str>> {
      ptr: core::ptr::non_null::NonNull<alloc::rc::RcBox<ddd::Node<&str>>> {
        pointer: 0x5555555a2aa0
      },
      phantom: core::marker::PhantomData<alloc::rc::RcBox<ddd::Node<&str>>>
    })
}

(gdb) x/4xg 0x5555555a2aa0
0x5555555a2aa0:	0x0000000000000001	0x0000000000000001
0x5555555a2ab0:	0x00005555555a2a70	0x000055555558f00b

(gdb) x/3xb 0x000055555558f00b
0x55555558f00b:	0x62	0x61	0x72                        ; bar

(gdb) x/4xg 0x00005555555a2a70
0x5555555a2a70:	0x0000000000000001	0x0000000000000001
0x5555555a2a80:	0x0000000000000000	0x000055555558f008

(gdb) x/3xb 0x000055555558f008
0x55555558f008:	0x66	0x6f	0x6f                        ; foo

双向链表实例

可以使用 downgrade 方法将一个 Rc<T> 类型转换成一个 Weak<T>类型。类似地，可以使用 upgrade 方法将一个 Weak<T> 类型转换成一个 R<T> 类型。downgrade 方法始终有效，而在弱引用上调用 upgrade 方法时，实际的值可能已经被删除，在这种情况下，你将获得的值是None。所以，添加一个只想上一个节点的弱指针。

use std::rc::Rc;
use std::rc::Weak;
use std::cell::RefCell;

#[derive(Debug)]
struct LinkedList<T> {
    head: Option<Rc<LinkedListNode<T>>>
}

#[derive(Debug)]
struct LinkedListNode<T> {
    next: Option<Rc<LinkedListNode<T>>>,
    prev: RefCell<Option<Weak<LinkedListNode<T>>>>,
    data: T
}

impl<T> LinkedList<T> {
    fn new() -> Self {
        LinkedList { head: None }
    }

    fn append(&mut self, data: T) -> Self {
        let new_node = Rc::new(LinkedListNode {
            data: data,
            next: self.head.clone(),
            prev: RefCell::new(None)
        });

        match self.head.clone() {
            Some(node) => {
                let mut prev = node.prev.borrow_mut();
                *prev = Some(Rc::downgrade(&new_node));
            },
            None => {

            }
        }

        LinkedList {
            head: Some(new_node)
        }
    }
}

fn main() {
    let list_of_nums = LinkedList::new().append(1).append(2).append(3);
    println!("nums: {:?}", list_of_nums);
}

双向链表结果:

list_of_nums = ddd::LinkedList<i32> {
  head: core::option::Option<alloc::rc::Rc<ddd::LinkedListNode<i32>>>::Some(Rc(strong=1, weak=1) = {
      value = ddd::LinkedListNode<i32> {
        next: core::option::Option<alloc::rc::Rc<ddd::LinkedListNode<i32>>>::Some(Rc(strong=1, weak=1) = {
            value = ddd::LinkedListNode<i32> {
              next: core::option::Option<alloc::rc::Rc<ddd::LinkedListNode<i32>>>::Some(Rc(strong=1, weak=0) = {
                  value = ddd::LinkedListNode<i32> {
                    next: core::option::Option<alloc::rc::Rc<ddd::LinkedListNode<i32>>>::None,
                    prev: RefCell(borrow=0) = {
                      value = core::option::Option<alloc::rc::Weak<ddd::LinkedListNode<i32>>>::Some(alloc::rc::Weak<ddd::LinkedListNode<i32>> {
                          ptr: core::ptr::non_null::NonNull<alloc::rc::RcBox<ddd::LinkedListNode<i32>>> {
                            pointer: 0x5555555a3a10
                          }
                        }),
                      borrow = 0
                    },
                    data: 1
                  },
                  strong = 1,
                  weak = 0
                }),
              prev: RefCell(borrow=0) = {
                value = core::option::Option<alloc::rc::Weak<ddd::LinkedListNode<i32>>>::Some(alloc::rc::Weak<ddd::LinkedListNode<i32>> {
                    ptr: core::ptr::non_null::NonNull<alloc::rc::RcBox<ddd::LinkedListNode<i32>>> {
                      pointer: 0x5555555a3a50
                    }
                  }),
                borrow = 0
              },
              data: 2
            },
            strong = 1,
            weak = 1
          }),
        prev: RefCell(borrow=0) = {
          value = core::option::Option<alloc::rc::Weak<ddd::LinkedListNode<i32>>>::None,
          borrow = 0
        },
        data: 3
      },
      strong = 1,
      weak = 1
    })
}

只让结构体的某个部分可变，可以通过RefCell进行修改:

// 1. 添加RefCell引用
use std::cell::RefCell;

// 2. 将RefCell添加到LinkedListNode
#[derive(Debug)]
struct LinkedListNode<T> {
  next: Option<Rc<LinkedListNode<T>>>,
  prev: RefCell<Option<Weak<LinkedListNode<T>>>>,
  data: T
}

// 3. 修改append方法以创建新的RefCell，并通过RefCell可变借用更新之前的引用
fn append(&mut self, data: T) -> Self {
  let new_node = Rc::new(LinkedListNode{
    data: data,
    next: self.head.Clone(),
    prev: RefCell::new(None)
  });

  match self.head.Clone() {
    Some(node) => {
      let mut prev = node.prev.borrow_mut();    // 借用
      *prev = Some(Rc::downgrade(&new_node));
    },
    None => {
    }
  }

  LinkedList {
    head: Some(new_node)
  }
}

自动解引用

自动解引用，可直接调用值方法。

use std::rc::Rc;

struct User {
    age: u8
}

impl User {
    fn test(&self) {
        println!("{}", self.age);
    }
}

fn main() {
    let rc = Rc::new(User{ age: 10 });
    rc.test();
}

内部可变性

Rust通过在任何给定作用域中仅允许一个可变引用，从而在编译时保证我们免受指针别名的影响。但是，在某些情况下，它会变得非常严格，因为严格的借用检查使我们知道由于代码的安全性而不能通过编译器的编译。对于这种情况，其中一个解决方案是将借用检查从编译时移动到运行时，这是通过内部可变性实现的。

继承可变性: 是获得某些结构体的 &mut 引用时默认取得的可变性。意味着你可以修改结构体中的任意字段。
内部可变性: 这种可变性中，即使你有一个引用某种类型的 &SomeStruct，如果其中的字段类型为 Cell<T> 或 RefCell<T>, 那么仍然可以修改其字段。

内部可变性(interior mutability)利用unsafe绕过借用规则，允许通过不可变引用修改内部值。

唯一所有权，运行期借用规则检查。
运行时行为，出错panic!。
单线程。

编译器静态规则检查过于保守，某些设计需要运行期操作。

在运行时不存在两个可变借用。这些类型将多个可变借用的检测从编译时移动到了运行时，如果存在对值的两个可变借用，就会发生异常。当希望向用户公开不可变API时，通常会遇到内部可变性，不过上述API内部存在部分可变性。标准库中有两个通用的智能指针类型提供了共享可变性: Cell 和 RefCell。

Cell

Cell<T>类型是一种智能指针类型，可以为值提供可变性，甚至允许值位于不可引用之后。它以极低的开销提供了此功能，并具有最简单的API。

Cell优势?

便捷版本Cell，开辟一块儿始终可变内存区域。

栈内存分配。
仅适合实现Copy特征的类型。

use std::cell::Cell;

struct Data {
    x: i64,
    y: Cell<i64>,
}

fn main() {
    let d = Data{ x: 1, y: Cell::new(2) };

    // d.x = 10;
    // ^^^^^^^^ cannot assign

    d.y.set(200);
    assert_eq!(d.y.get(), 200);
}

(gdb) ptype d.y                         // Cell数据类型
type = struct core::cell::Cell<i64> {
  value: core::cell::UnsafeCell<i64>,
}

(gdb) info locals
d = ddd::Data {
  x: 1,
  y: core::cell::Cell<i64> {
    value: core::cell::UnsafeCell<i64> {
      value: 2
    }
  }
}

(gdb) p/x &d                            // 分配在stack
$1 = 0x7fffffffe350

(gdb) x/2xg 0x7fffffffe350
0x7fffffffe350:	0x0000000000000001	0x0000000000000002

(gdb) info proc  mappings
0x7ffffffde000     0x7ffffffff000    0x21000        0x0 [stack]

// d.y.set(200) 实现

0x0000555555559585 <+53>:	mov    rdi,rcx
0x0000555555559588 <+56>:	mov    esi,0xc8
0x000055555555958d <+61>:	call   0x5555555591b0 <core::cell::Cell<T>::set>

(gdb) p/x $rsp+0x40
$1 = 0x7fffffffe350

(gdb) x/2xg  0x7fffffffe350
0x7fffffffe350:	0x0000000000000001	0x00000000000000c8          // 0xc8 被设置为新值

// refCell.set() 函数源码剖析
pub fn set(&self, val: T) {
    let old = self.replace(val);    // 设置新值
    drop(old);                      // 删除旧值
}

Cell 常用方法

Cell::new: 允许你通过传递任意类型 T 来创建 Cell 类型的新实例。
get: 允许你复制单元(cell)中的值。仅当包装类型 T 为Copy时，该方法才有效。
set: 允许用户修改内部的值，即使该值位于某个不可变引用的后面。

以下实例将两个可变引用修改bag中的内容:

use std::cell::Cell;

#[derive(Debug)]
struct Bag {
    item: Box<u32>
}

fn main() {
    let mut bag = Cell::new(Bag { item: Box::new(1) });
    let hand1 = &mut bag;
    let hand2 = &mut bag;

    *hand1 = Cell::new(Bag { item: Box::new(2) });

}

由于借用规则限制，不支持同时多次修改两个可变借用。

error[E0499]: cannot borrow `bag` as mutable more than once at a time
  --> src/main.rs:15:17
   |
14 |     let hand1 = &mut bag;
   |                 -------- first mutable borrow occurs here
15 |     let hand2 = &mut bag;
   |                 ^^^^^^^^ second mutable borrow occurs here
16 |
17 |     *hand1 = Cell::new(Bag { item: Box::new(2) });
   |     ------ first borrow later used here

error: aborting due to previous error

可以通过将bag的值封装到Cell中来让它正常运转。

use std::cell::Cell;

#[derive(Debug)]
struct Bag {
    item: Box<u32>
}

fn main() {
    let bag = Cell::new(Bag { item: Box::new(1) });
    let hand1 = &bag;
    let hand2 = &bag;

    hand1.set(Bag { item: Box::new(2) });
    hand2.set(Bag { item: Box::new(3) });
}

RefCell

如果需要某个非Copy类型支持Cell的功能，可以使用RefCell类型。

它采用了和借用类似的读/写模式，但是将借用检查移动到运行时，这很方便，但不是零成本。RefCell 分发值的引用不像 Cell类型那样按值返回。

RefCell 实例1: 基本使用

use std::cell::RefCell;

fn main() {
    let c = RefCell::new(5);

    {
        let r1 = c.borrow();            // &T
        let r2 = c.borrow();            // &T

        assert_eq!(*r1, 5);
        assert_eq!(*r1, *r2);
    }

    {
        let mut r = c.borrow_mut();     // &mut T
        *r = 10;
    }

    assert_eq!(c.into_inner(), 10);     // c 被释放
}

// RefCell 结构

(gdb) ptype c
type = struct core::cell::RefCell<i32> {
  borrow: core::cell::Cell<isize>,
  value: core::cell::UnsafeCell<i32>,
}

// 结构体示意图

   stack              heap
  +=====+           +============+
  | ptr | --------> | borrow_cnt |    RefCell<T>
  +=====+           +------------+    borrow_mut: count = -1
                    | value      |
                    +============+

// RefCell::new(5) 初始化后，borrow计数为0

(gdb) info locals
c = core::cell::RefCell<i32> {
  borrow: core::cell::Cell<isize> {
    value: core::cell::UnsafeCell<isize> {
      value: 0
    }
  },
  value: core::cell::UnsafeCell<i32> {
    value: 5
  }
}

(gdb) x/2xg 0x7fffffffe1d0
0x7fffffffe1d0:	0x0000000000000000	0x0000000000000005


// borrow_mut调用borrow_cnt()后，将计数置为-1

c = core::cell::RefCell<i32> {
  borrow: core::cell::Cell<isize> {
    value: core::cell::UnsafeCell<isize> {
      value: -1
    }
  },
  value: core::cell::UnsafeCell<i32> {
    value: 5
  }
}

// 调用borrow_cnt后，结构体发生改变
// let mut r = c.borrow_mut();

(gdb) ptype r
type = struct core::cell::RefMut<i32> {
  value: *mut i32,
  borrow: core::cell::BorrowRefMut,
}

// let mut r = c.borrow_mut(); 后，r变量引用置为负数，可通过r进行修改r指向堆上的值
r = core::cell::RefMut<i32> {
  value: 0x7fffffffe1d8,
  borrow: core::cell::BorrowRefMut {
    borrow: 0x7fffffffe1d0
  }
}

(gdb) x/xg 0x7fffffffe1d8                       // 值
0x7fffffffe1d8:	0x0000000000000005

(gdb) x/xg 0x7fffffffe1d0                       // 一个负数补码
0x7fffffffe1d0:	0xffffffffffffffff

实例2: 改造Rc

改造Rc，使其可变。

use std::rc::Rc;
use std::cell::RefCell;

fn main() {
    let rc = Rc::new(RefCell::new(5));
    let rc2 = rc.clone();

    {
        let mut r = rc.borrow_mut();
        *r = 100;
    }

    assert_eq!(*rc2.borrow(), 100);
}

(gdb) info locals
r = core::cell::RefMut<i32> {
  value: 0x55555559f928,
  borrow: core::cell::BorrowRefMut {
    borrow: 0x55555559f920
  }
}

rc2 = alloc::rc::Rc<core::cell::RefCell<i32>> {
  ptr: core::ptr::non_null::NonNull<alloc::rc::RcBox<core::cell::RefCell<i32>>> {
    pointer: 0x55555559f910
  },
  phantom: core::marker::PhantomData<alloc::rc::RcBox<core::cell::RefCell<i32>>>
}

rc = alloc::rc::Rc<core::cell::RefCell<i32>> {
  ptr: core::ptr::non_null::NonNull<alloc::rc::RcBox<core::cell::RefCell<i32>>> {
    pointer: 0x55555559f910
  },
  phantom: core::marker::PhantomData<alloc::rc::RcBox<core::cell::RefCell<i32>>>
}

// let mut r = rc.borrow_mut(), r borrow指向rc2(rc) RefCell.value地址
(gdb) x/4xg 0x55555559f910
0x55555559f910:	0x0000000000000002	0x0000000000000001
0x55555559f920:	0xffffffffffffffff	0x0000000000000005

// *r = 100, 更改r.borrow 指向heap内容，即rc2(rc).value位置的值
(gdb) x/4xg 0x55555559f910
0x55555559f910:	0x0000000000000002	0x0000000000000001
0x55555559f920:	0xffffffffffffffff	0x0000000000000064

实例3: borrow_mut 和 borrow使用实例

use std::cell::RefCell;

#[derive(Debug)]
struct Bag {
    item: Box<u32>
}

fn main() {
    let bag = RefCell::new(Bag { item: Box::new(1) });
    let hand1 = &bag;
    let hand2 = &bag;
    *hand1.borrow_mut() = Bag { item: Box::new(2) };
    *hand2.borrow_mut() = Bag { item: Box::new(3) };
    let borrowed = hand1.borrow();
    println!("{:?}", borrowed);
}

尝试在统一作用域中调用上述两种方法:

use std::cell::RefCell;

#[derive(Debug)]
struct Bag {
    item: Box<u32>
}

fn main() {
    let bag = RefCell::new(Bag { item: Box::new(1) });
    let hand1 = &bag;
    let hand2 = &bag;
    *hand1.borrow_mut() = Bag { item: Box::new(2) };
    *hand2.borrow_mut() = Bag { item: Box::new(3) };
    println!("{:?} {:?}", hand1.borrow(), hand1.borrow_mut());
}

root@8d75790f92f5:~/rs/ddd/src# cargo r
   Compiling ddd v0.1.0 (/root/rs/ddd)
    Finished dev [unoptimized + debuginfo] target(s) in 3.87s
     Running `/root/rs/ddd/target/debug/ddd`
thread 'main' panicked at 'already borrowed: BorrowMutError', src/main.rs:20:49
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

出现上述错误，是因为独占可变访问具有相同的所有权规则。但是，对于 RefCell，这会在运行时进行检查。对于这种情况，必须明确使用单独的代码块分隔借用，或者使用 drop 方法删除引用。

RefCell Vs. Cell

Cell比RefCell 更轻，性能更好，用法更方。但是Cell只能包装Copy类型，而RefCell可以包装任何类型，并且RefCell可以获取其内部包装对象的引用，并在运行时检测可变引用的唯一性。

具体数据结构:

// library/core/src/cell.rs

pub struct Cell<T: ?Sized> {
    value: UnsafeCell<T>,                                                       // 内部对象
}

// RefCell
type BorrowFlag = isize;

pub struct RefCell<T: ?Sized> {
    borrow: Cell<BorrowFlag>,                                                   // 对象引用类别和计数器
    borrowed_at: Cell<Option<&'static crate::panic::Location<'static>>>,        // 借用最开始&活跃的位置
    value: UnsafeCell<T>,                                                       // 内部对象
}

// &mut T
pub struct RefMut<'b, T: ?Sized + 'b> {
    value: &'b mut T,
    borrow: BorrowRefMut<'b>,
}

RefCell内部维护了一个包装对象的引用计数，当RefCell.borrow获取一个共享引用时，内部引用计数加1，当获取的引用离开作用域时，内部引用计数减1，当RefCell.borrow_mut获取一个可变引用时，首先检测引用计数是否为0，如果为0，正常返回，否则panic；其实RefCell.borrow也会做类似的检测，当已经获取了可变引用也是直接panic，当然为了避免panic，我们可以用RefCell.try_borrow和RefCell.try_borrow_mut来获取一个Result类型。

因为Cell和RefCell两种类型都未实现Sync trait，所以这两种类型只能用于单线程中，不能跨线程操作，如果需要跨线程操作，就需要用到Mutex和RwLock了。

Cell 和 RefCell类型不是线程安全(thead-safety)的。这意味着 Rust 不允许用户在多线程环境中共享这些类型。

内部可变性的应用

使用两个整数和sum方法来扩展结构体，以缓存求和的结果，并返回缓存的值。

use std::cell::Cell;

struct Point {
    x: u8,
    y: u8,
    cached_sum: Cell<Option<u8>>
}

impl Point {
    fn sum(&self) -> u8 {
        match self.cached_sum.get() {
            Some(sum) => {
                println!("Got from cache: {}", sum);
                sum
            },
            None => {
                let new_sum = self.x + self.y;
                self.cached_sum.set(Some(new_sum));
                println!("Set cache: {}", new_sum);
                new_sum
            }
        }
    }
}

fn main() {
    let p = Point { x: 8, y: 9 , cached_sum: Cell::new(None) };
    println!("Summed result: {}", p.sum());
    println!("Summed result: {}", p.sum());
}

rust异常处理

2021-07-22T00:00:00+00:00

Rust中大多数错误处理都是通过 Option 和 Result这两种通用类型完成的。 Option 和 Result 类型是标准库中的普通类型，这意味着它们不是编译器内部类型，所以编译器会将它们和其他函数一视同仁。任何人都可以使用枚举和泛型功能创建类似的错误抽象类型。

大多数异常处理一般有三种。

可恢复异常。例如文件未找到(file not found)或数字解析错误。
不可恢复异常。例如索引越界或除以非零的操作(分母是零)。
致命性异常。包括内存不足和堆栈溢出。

Result

通常使用 Result 的枚举对象作为程序的返回值，通过Result来判断其结果，我们使用match匹配的方式来获取Result的内容，判断正常(Ok)或错误(Err)。

Result是一个enum枚举对象，具体源码:

pub enum Result<T, E> {
    /// Contains the success value
    Ok(#[stable(feature = "rust1", since = "1.0.0")] T),

    /// Contains the error value
    Err(#[stable(feature = "rust1", since = "1.0.0")] E),
}

Error具体实现

Error 是一个trait，具体由Display、source方法实现。

// library/std/src/error.rs

#[stable(feature = "rust1", since = "1.0.0")]
pub trait Error: Debug + Display {
    #[stable(feature = "error_source", since = "1.30.0")]
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        None
    }
`
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_deprecated(since = "1.42.0", reason = "use the Display impl or to_string()")]
    fn description(&self) -> &str {
        "description() is deprecated; use Display"
    }
}

description: 该方法不再推荐使用，而是由Display代替。
source：进行错误输出，有错误则返回Err，返回Some(e);如果没有返回None。

异常处理简单示例

fn read_file(path: &str) -> Result<String, std::io::Error> {    // Result作为结果返回值
    std::fs::read_to_string(path)                               // 读取文件内容
}

fn main() {
    let path = "/tmp/data";     // 文件路径
    match read_file(path) {
        Ok(file)    =>  { println!("{}", file) }            // OK 代表读取到文件内容，正确打印文件内容
        Err(e)      =>  { println!("{} {}", path, e) }      // Err代表结果不存在，打印错误结果
    }
}

自定义Error

自定义的Error需要impl std::fmt::Debug的trait。具体实现一个自定义Error需要以下几步骤:

实现impl std::fmt::Display的trait, 并实现fmt(...)方法。
实现impl std::fmt::Debug的trait, 一般直接添加注释即可: #[derive(Debug)]。
实现impl std::error::Error的trait，并根据自身error级别是否覆盖 std::error::Error中的source()方法。

自定义错误: SimpleError

use std::error::Error;

// 1. 自定义类型Error，实现 std::fmt::Debug的trait
#[derive(Debug)]
struct SimpleError {
    err: ChildError,
}

// 2. 实现Display的trait，并实现fmt方法
impl std::fmt::Display for SimpleError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "SimpleError!!!")
    }
}

// 3. 实现Error的trait，因为有子Error::ChildError，需要覆盖source()方法，返回Some(err)
impl std::error::Error for SimpleError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        Some(&self.err)
    }
}

子类型错误ChildError:

// 4. 子类型Error，实现std::fmt::Debug的trait
#[derive(Debug)]
struct ChildError;

// 5. 实现Display的trait，并实现fmt方法
impl std::fmt::Display for ChildError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "ChildError!!!")
    }
}

// 6. 实现Error的trait,因为没有子Error,不需要覆盖source()方法
impl std::error::Error for ChildError {}

使用自定义Error

// 构建一个Result的结果，返回自定义的error:SimpleError
fn get_super_error() -> Result<(), SimpleError> {
    Err(SimpleError { err: ChildError })
}

fn main() {
    match get_super_error() {
        Err(e) => {
            println!("Error: {}", e);
            println!("Caused by: {}", e.source().unwrap());
        }
        _ => println!("No error"),
    }
}

ChildError为子类型Error，没有覆盖source()方法。
SimpleError有子类型ChildError，覆盖了 source()，并返回了类型Option值Some(&self.err)

自定义错误转换: From

可以将多个单独的Error 放到一个自定义Error 中，将多个单独的Error 类型变成自定义Error 的子Error，这样对外的Result统一返回自定义Error。

#[derive(Debug)]
enum CustomError {
    ParseIntError(std::num::ParseIntError),
    Utf8Error(std::str::Utf8Error),
    IoError(std::io::Error),
}

impl std::error::Error for CustomError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static')> {
        match &self {
            CustomError::IoError(ref e)     => Some(e),
            CustomeError::Utf8Error(ref e)  => Some(e),
            CustomeError::ParseIntError(ref f) => Some(e),
        }
    }
}

import Display for CustomError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match &self {
            CustomError::IoError(ref e)     => e.fmt(f),
            CustomeError::Utf8Error(ref e)  => e.fmt(f),
            CustomeError::ParseIntError(ref f) => e.fmt(f), 
        }
    }
}

impl From<ParseIntError> for CustomError {
    fn from(s: std::num::ParseIntError) -> Self {
        CustomError::ParseIntError(s)
    }
}

impl From<IoError> for CustomError {
    fn from(s: std::io::Error) -> Self {
        CustomError::IoError(s)
    }
}

impl From<Utf8Error> for CustomError {
    fn from(s: std::str::Utf8Error) -> Self {
        CustomError::Utf8Error(s)
    }
}

CustomError实现了自定义Error
CustomError有三个子类型Error
CustomError分别实现了三个子类型ErrorFrom的trait,将其类型包装为自定义Error的子类型

使用自定义Error

use std::io::Error as IoError;
use std::str::Utf8Error;
use std::num::ParseIntError;
use std::fmt::{Display, Formatter};

fn main() -> std::result::Result<(), CustomError>{
    // 1. 读取一个文件
    // 2. 转成utf8
    // 3. 转成u32

    let path = "./dat";
    let v = read_file(path)?;
    let x = to_utf8(v.as_bytes())?;
    let u = to_u32(x)?;
    println!("num:{:?}", u);

    Ok(())
}

// 读取文件内容
fn read_file(path: &str) -> std::result::Result<String, std::io::Error> {
    std::fs::read_to_str(path)
}

// 转换成utf8内容
fn to_utf8(v: &[u8]) -> std::result::Result<&str, std::str::Utf8Error> {
    std::str::from_utf8(v)
}

// 转成为u32数字
fn to_u32(v: &str) -> std::result::Result<u32, std::num::ParseIntError> {
    v.parse::<u32>()
}

使用?代替原来的match匹配方式。?使用问号作用在函数的结束，意思是:

接受了一个Result<(), CustomError> 错误类型
如果函数返回错误，则抛出Err异常，包含CustomError错误信息(因为impl Form转换的操作，该函数的自身类型错误会通过实现的From操作自动转化为CustomError的自定义类型错误),退出当前函数。
如果函数返回值正常，继续之后逻辑，直到程序结束

重命名Result

在项目中，会大量使用Result结果，并且Result的Err类型是我们自定义错误，导致我们写程序时会显得啰嗦、冗余。

// 读取文件内容
fn read_file(path: &str) -> std::result::Result<String, CustomError> {
    let val = std::fs::read_to_string(path)?;
    Ok(val)
}

// 转换为utf8内容
fn to_utf8(v: &[u8]) -> std::result::Result<&str, CustomError> {
    let x = std::str::from_utf8(v)?;
    Ok(x)
}

// 转化为u32数字
fn to_u32(v: &str) -> std::result::Result<u32, CustomError> {
    let i = v.parse::<u32>?;
    Ok(i)
}

在项目中，大量充斥着这种模版代码，Rust本身支持对类型自定义，只需要重命名Result即可。

// 自定义Result类型：IResult
pub type IResult<I> = std::result::Result<I, CustomError>;

这样，凡是使用的是自定义类型错误的Result都可以使用IResult来替换std::result::Result的类型，使得简化程序，隐藏Error类型及细节。

// 读取文件内容
fn read_file(path: &str) -> IResult<String> {
    let val = std::fs::read_to_string(path)?;
    Ok(val)
}

// 转换为utf8内容
fn to_utf8(v: &[u8]) -> IResult<&str> {
    let x = std::str::from_utf8(v)?;
    Ok(x)
}

// 转化为u32数字
fn to_u32(v: &str) -> IResult<u32> {
    let i = v.parse::<u32>?;
    Ok(i)
}

将std::result::Result<I, CustomError> 替换为 IResult<I>类型。

如果多参数类型，只需要将OK类型变成tuple(I, O)类型的多参数数据即可。

pub type IResult<I, O> = std::result::Result<(I, O), CustomError>;

// 具体使用
fn foo() -> IResult<String, u32> {
    Ok((String::from("bar"), 32))
}

rust异常处理-可恢复错误

2021-07-21T00:00:00+00:00

可恢复性（recoverable）错误通常指一种状态，比如打开文件时，没找到，应该新建。显然，最终如何处理，由调用方负责。没有异常，对于可恢复性错误，返回Result<T, E>对象。

Option

Rust中没有 null 值的概念，在Rust中，可能失败并希望指示缺失相应值的API会返回 Option。当任何API及其后续值想要表示缺少值时，此错误类型就是合适的。简而言之，它与null值类似，不过这里的 null 值检查是显式的，并且在编译期由类型系统强制执行。

Option包含以下标签签名:

pub enum Option<T> {
    /// 没有值
    None,

    /// 包含某些值 'T'
    Some(T),
}

它是包含两个变体的枚举，并且 T 是泛型。操作成功时，可以使用Some(T)存储任意类型值T，或者使用 None 变量表示操作失败的情况下该值为null。

let wrapped_i32 = Some(2);          // Some(T)

let empty: Option<i32> = None;      // None

let empty = None::<i32>;            // None

prelude模块

Rust的标准库，有一个 prelude 子模块，该模块自动导入了常用的类型、函数和任意标准库模块的重新导出。导入后，允许直接通过变体实例话 Option 值。

目前版本导入以下内容:

//! [mem::drop]: crate::mem::drop
//! [std::borrow]: crate::borrow
//! [std::boxed]: crate::boxed
//! [std::clone]: crate::clone
//! [std::cmp]: crate::cmp
//! [std::convert]: crate::convert
//! [std::default]: crate::default
//! [std::iter]: crate::iter
//! [std::marker]: crate::marker
//! [std::mem]: crate::mem
//! [std::ops]: crate::ops
//! [std::option]: crate::option
//! [`std::prelude::v1`]: v1
//! [std::result]: crate::result
//! [std::slice]: crate::slice
//! [std::string]: crate::string
//! [std::vec]: mod@crate::vec
//! [`to_owned`]: crate::borrow::ToOwned::to_owned
//! [book-closures]: ../../book/ch13-01-closures.html
//! [book-dtor]: ../../book/ch15-03-drop.html
//! [book-enums]: ../../book/ch06-01-defining-an-enum.html
//! [book-iter]: ../../book/ch13-02-iterators.html

Option 交互

如下实例，value 是一个 Option<&i32>。get() 方法返回的是一个 Option<&i32>，而不是其内部的值(&i32)。为了给 value的值加1，我们需要从 Option中提取 i32。为了检查变体，我们有两种方法，他们分别是 模式匹配 和 if let 语句。

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert("one", 1);
    map.insert("two", 2);

    let incremented_value = match map.get("one") {
        Some(val) => val + 1,
        None => 0
    };

    println!("{}", incremented_value);
}

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert("one", 1);
    map.insert("two", 2);

    let incremented_value = if let Some(v) = map.get("one") {
        v + 1
    } else {
        0
    };

    println!("{}", incremented_value);
}

当我们对值的某个变体感兴趣并希望对其他变体进行常规的操作时，推荐使用这种方法。if let 语句表述更简洁。

Unwrapping

Result<T, E> 类型定义了很多辅助方法来处理各种情况，其中之一叫做unwrap。

如果Result值是成员OK, unwrap会返回OK中的值。
如果Result是成员Err，unwrap会为我们调用panic!。

Unwrapping是一种不太安全的方法在 Option 上调用解压缩方法。如果返回的结果是 Some，那么调用 unwrap() 和 expect()方法提取内部的值；如果返回的结果是 None，则会发生异常。

仅当我们确定 Option 值确实包含某个值时，才推荐使用这些方法。

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert("one", 1);
    map.insert("two", 2);

    let incremented_value = map.get("two").unwrap() + 1;
    println!("{}", incremented_value);
}

get一个不存在的键值，则发生异常。

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert("one", 1);
    map.insert("two", 2);

    let incremented_value = map.get("three").unwrap() + 1;
    println!("{}", incremented_value);
}

root@8d75790f92f5:~/rs/ddd/src# cargo r
   Compiling ddd v0.1.0 (/root/rs/ddd)
    Finished dev [unoptimized + debuginfo] target(s) in 5.21s
     Running `/root/rs/ddd/target/debug/ddd`
thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', src/main.rs:12:46
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

unwrap() 和 expect() 区别

expect() 是首选方法，因为它允许你传递一个字符串作为发生异常时输出的提示信息，同时显示源文件发生异常时的确切代码行号。
unwrap() 不允许你将调试信息作为参数进行传递，并显示在标准库源文件中 Option 下定义 unwrap()的代码行号。

Result<T, E>

Result 和 Option 类似，但具有一些优点，即能够存储和错误上下文有关的异常值，而不只是 None。当我们希望知道操作失败的原因时，此类型是合适的。

Result类型签名:

enum Result<T, E> {
    Ok(T),
    Err(E),
}

它包含两个变体，并且都是泛型。Ok(T)是用于表示成功状态时放入任意值 T 的变体，而 Err(E) 是用于表示执行失败时放入任何异常值 T的变体。

fn main() {
    // Ok(T)
    let _my_result: Result<_, ()> = Ok(64);
    let _my_result = Ok::<_, ()>(64);

    // Err(E)
    let _my_err = Err::<(), f32>(354.3);
    let _other_err: Result<bool, String> = Err("Wait, What ?".to_string());
}

使用 () 指定 Err 变体的类型 E。可以使用 _来要求Rust为我们推断具体的类型。

Result实例

标准库中的许多文件操作API都会返回 Result 类型，因为可能存在不同的操作失败原因，例如找不到文件(file not found)、目录不存在(directory does not exists)，以及权限错误(permission errors)等。

use std::fs::File;
use std::io::Read;
use std::path::Path;

fn main() {
    let path = Path::new("data.txt");
    let mut file = match File::open(&path) {
        Ok(file)    => file,
        Err(err)    => panic!("Error while opening file: {}", err),
    };

    let mut s = String::new();
    let _ = file.read_to_string(&mut s);
    println!("Message: {}", s);
}

传播

可通过 return Err将错误按调用堆栈传递出去。

fn div(x: i32, y: i32) -> Result<i32, &'static str> {
    if y != 0 { 
        Ok(x / y) 
    } else { 
        Err("divide by zero") 
    }
}

fn test(x: i32, y: i32) -> Result<i32, &'static str> {
    let z = div(x, y);
    if z.is_err() { return z; }  // 传播！
    z
}

fn main() {
    test(3, 0).unwrap();        // 处理错误！
}                                      

root@8d75790f92f5:~/rs/ddd/src# cargo r
   Compiling ddd v0.1.0 (/root/rs/ddd)
    Finished dev [unoptimized + debuginfo] target(s) in 3.55s
     Running `/root/rs/ddd/target/debug/ddd`
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: "divide by zero"', src/main.rs:22:16
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Option/Result的组合

由于 Option 和 Result 是包装器类型，因此安全地与其内部值进行交互的唯一方法是通过模式匹配或if let语句。这些包装器类型附带了很多辅助方法，这些被称为组合器，其上的实现允许用户轻松地操作内部值。

这些是泛型方法，根据使用场景不同而包含多种，例如 Ok(T)/Some(T)，而其中一些方法用于处理失败的值，例如 Err(E)/None。某些方法用于拆解和提取内部值，而有些方法会保留包装器类型的结构，仅修改内部值。

注意:

成功值时，通常指的是 Ok(T)/Some(T)变量；失败值时，通常指的是 Err(T)/None(T) 变量。

常见的组合器

map() 此方法允许你将表示成功的值 T 转换为另一个值 U。以下是 Option 类型对应 map 特征签名:

pub fn map<U, F>(self, f: F) -> Option<U>
where
    F: FnOnce(T) -> U
{
    match self {
        Some(x) => Some(f(x)),
        None => None,
    }
}

以下是和Result类型有关的签名:

pub fn map<U, F>(self, f: F) -> Option<U>
where F: FnOne(T) -> U {
    match self {
        Ok(t) => Ok(f(t)),
        Err(e) => Err(e)
    }
}

这是特征的某种特殊类型，仅适用于闭包，因此具有 (T) -> U 这样的函数签名。FnOnce 前缀表示此闭包取得输入参数 T 的所有权，并且我们只能用 T 调用此闭包一次，因为 T 将在执行调用后被使用。

组合器应用

fn get_nth(items: &Vec<usize>, nth: usize) -> Option<usize> {
    if nth < items.len() {
        Some(items[nth])
    } else {
        None
    }
}

fn double(val: usize) -> usize {
    val * val
}

fn main() {
    let items = vec![7, 6, 5, 4, 3, 5, 3, 10, 3, 2, 4];
    println!("{}", items.len());

    let doubled = get_nth(&items, 4).map(double);
    println!("{:?}", doubled);
}

还可以提供一个内联形式的闭包，如下所示:

let doubled = get_nth(&items, 4).map(|v| v*v);

这是链式调用的简易形式。并且比之前使用的 match 表达式和 if let语句更简单。

Option 和 Result 类型之间转换

还有一些方法可以将一种包装器转换成另一种包装器类型。

ok_or: 将 Option值转换为Result值，同时将错误值作为第二个参数进行接收。此类型的变体是ok_or_else方法，但优于此方法，因为它接收闭包来进行惰性求值。
ok: 此方法将Result转化为调用self的Option，并且会丢弃Err值。

fn main() {
    let x = Some("foo");
    let _y = x.ok_or(0);
    assert_eq!(x.ok_or(0), Ok("foo"));

    println!("xxx");
}

_y = core::result::Result<&str, i32>::Ok("foo")
x = core::option::Option<&str>::Some("foo")

运算符 “?”

使用?来代替原来的match匹配的方式。?作用在函数的结束。

它的运行机制如下: 当我们获得一个成功值时，希望立即提取它；当我们获得一个错误值时，希望提前返回，并将错误传播给调用方。

要么解构出Ok关联值，要么return Err向外传播。
只能用于Result<T, E>返回值的函数。
隐式传播的Err关键值类型必须相同，或可自动转换。

fn div(x: i32, y: i32) -> Result<i32, &'static str> {
    if y != 0 {
        Ok(x/ y)
    } else {
        Err("divide by zero")
    }
}

fn test(x: i32, y: i32) -> Result<i32, &'static str> {
    let z: i32 = div(x, y)?;            // z返回值为i32或者Err
                                        // 如果div函数结果正确，继续之后逻辑，直到程序结束

    Ok(z)                               // Ok将成功值，解构为Result进行返回
}

fn main() {
    test(3, 0).unwrap();
}

具体实例

它常用的 match 表达式来处理 Result类型:

use std::string::FromUtf8Error;

fn str_upper_match(str: Vec<u8>) -> Result<String, FromUtf8Error> {
    let ret = match String::from_utf8(str) {
        Ok(str) => str.to_uppercase(),
        Err(err) => return Err(err)
    };

    println!("Conversion succeeded: {}", ret);
    Ok(ret)
}

fn main() {
    let invalid_str = str_upper_match(vec![197, 198]);
    println!("{:?}", invalid_str);
}

运算符 ? 抽象了这种模式，这使我们能够以一种更简洁的方式编写 bytes_to_str 方法。

use std::string::FromUtf8Error;

fn str_upper_concise(str: Vec<u8>) -> Result<String, FromUtf8Error> {
    let ret = String::from_utf8(str).map(|s| s.to_uppercase())?;
    println!("Conversion succeeded: {}", ret);
    Ok(ret)
}

fn main() {
    let valid_str = str_upper_concise(vec![121, 97, 89]);
    println!("{:?}", valid_str);
}

链式调用

File.open("hello.txt")?.read_to_string(&mut s)?;

rust异常处理-不可恢复错误

2021-07-20T00:00:00+00:00

不可恢复错误

Rust提供了一种被称为panic(故障)的机制，它会终止调用它的线程，而不会影响任何其他线程。宏panic!主要用于测试，以及不可恢复性(unrecoverable)错误。当 panic!宏被调用时，发生灾难性故障的线程开始展开函数调用堆栈，从调用它的位置开始，一直到线程入口点。

为了找出导致灾难性故障的一系列调用，我们可以通过运行任何发生灾难性故障的程序，并在命令行设置环境变量 RUST_BACKTRACE=1 来查看线程中的回溯。

通常不可恢复性错误代表bug，或系统环境变量故障。

struct X {
    n: i32,
}

impl Drop for X {
    fn drop(&mut self) {
        println!("Dropping {}!", self.n);
    }
}

fn test() {
    let _x = X{n: 2};
    panic!("panic test.");
}

fn main() {
    let _y = X{n: 1};
    test();
}

root@8d75790f92f5:~/rs/closure/src# cargo r
    Finished dev [unoptimized + debuginfo] target(s) in 0.21s
     Running `/root/rs/closure/target/debug/closure`
thread 'main' panicked at 'panic test.', src/main.rs:13:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Dropping 2!
Dropping 1!

root@8d75790f92f5:~/rs/closure/src# RUST_BACKTRACE=1 cargo r
    Finished dev [unoptimized + debuginfo] target(s) in 0.07s
     Running `/root/rs/closure/target/debug/closure`
thread 'main' panicked at 'panic test.', src/main.rs:13:5
stack backtrace:
   0: std::panicking::begin_panic
             at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b/library/std/src/panicking.rs:519:12
   1: closure::test
             at ./main.rs:13:5
   2: closure::main
             at ./main.rs:18:5
   3: core::ops::function::FnOnce::call_once
             at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b/library/core/src/ops/function.rs:227:5
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
Dropping 2!
Dropping 1!

可在 Cargo.toml 中设置以终止(abort)代替展开，不回溯清理，直接终止进程。

对于部署的发型版(release version)，展开信息可能没什么用。

还可删除(strip)符号表，避免错误信息造成泄漏。

# Cargo.toml

[profile.release]
panic = 'abort'

root@8d75790f92f5:~/rs/closure/src# cargo r --release
    Finished release [optimized] target(s) in 0.05s
     Running `/root/rs/closure/target/release/closure`
thread 'main' panicked at 'panic test.', src/main.rs:13:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Aborted

常用场景

除直接调用外，以下场景也会引发panic!错误。

越界访问
被除以零
Option.unwrap/expect(可选值)
Result.unwarp/expect(返回值)

unwrap和expect区别？

expect 与 unwrap 的使用方式一样：返回OK或调用panic!宏

expect 用来调用 panic! 的错误信息将会作为参数传递给 expect ，而不像unwrap 那样使用默认的 panic! 信息。

自定义错误和Error特征

Rust没有类型层级继承，但它具有特征继承，并为我们提供了任何类型都可以实现的 Error 特征，从而构造自定义错误类型。Error 特征的类型签名:

pub trait Error: Debug + Display {
    fn description(&self) -> &str {
        // ...
    }

    fn cause(&self) -> Option<&dyn Error> {
        // ...
    }
}

创建自定义错误类型，该类型必须实现 Error 特征。

description：返回一个字符串切片引用，它是描述错误内容的可读形式。
cause：返回一个 Error 特征对象的可选引用，用于表示可能导致错误发生的底层原因。

// src/error.rs

#![allow(dead_code)]

use std::error::Error;
use std::fmt;
use std::fmt::Display;

#[derive(Debug)]
pub enum ParseErr {
    Malformed,
    Empty
}

#[derive(Debug)]
pub struct ReadErr {
    pub child_err: Box<dyn Error>
}

// Error 特征要求的
impl Display for ReadErr {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Failed reading todo file")
    }
}

// Error 特征要求的
impl Display for ParseErr {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Todo list parsing failed")
    }
}

impl Error for ReadErr {
    fn description(&self) -> &str {
        "Todolist read failed: "
    }

    fn cause(&self) -> Option<&dyn Error> {
        Some(&*self.child_err)
    }
}

impl Error for ParseErr {
    fn description(&self) -> &str {
        "Todolist parse failed: "
    }

    fn cause(&self) -> Option<&dyn Error> {
        None
    }
}

// src/lib.rs

// ! 该程序库提供了一个解析 todos 列表的API

use std::fs::read_to_string;
use std::path::Path;

mod error;
use error::ParseErr;
use error::ReadErr;

use std::error::Error;

// 该结构体包含了一个解析为 Vec<String>的 todos 列表
#[derive(Debug)]
pub struct TodoList {
    tasks: Vec<String>,
}

impl TodoList {
    pub fn get_todos<P>(path: P) -> Result<TodoList, Box<dyn Error>>
    where
    P: AsRef<Path>, {
        let read_todos: Result<String, Box<dyn Error>> = read_todos(path);
        let parsed_todos = parse_todos(&read_todos?)?;
        Ok(parsed_todos)
    }
}

pub fn read_todos<P>(path: P) -> Result<String, Box<dyn Error>>
where
    P: AsRef<Path>,
{
    let raw_todos = read_to_string(path)
        .map_err(|e| ReadErr {
            child_err: Box::new(e),
        })?;
    Ok(raw_todos)
}

pub fn parse_todos(todo_str: &str) -> Result<TodoList, Box<dyn Error>> {
    let mut tasks: Vec<String> = vec![];
    for i in todo_str.lines() {
        tasks.push(i.to_string());
    }

    if tasks.is_empty() {
        Err(ParseErr::Empty.into())
    } else {
        Ok(TodoList { tasks })
    }
}

// examples/basics.rs

extern crate ddd;

use ddd::TodoList;

fn main() {
    let todos = TodoList::get_todos("examples/todos");
    match todos {
        Ok(list) => println!("{:?}", list),
        Err(e) => {
            println!("{}", e);
            println!("{:?}", e);
        }
    }
}

通过 cargo run --example basic 命令执行 basics.rs 示例：

分歧函数

分歧函数(diverging)表示永远不会返回(never return)的函数。

无限循环main loop
包装panic!，用于调试或跟踪调用堆栈
紧急终止进程

fn test() -> ! {            // ! 分歧函数
    panic!("This function never returns!");
}

fn main() {
    let _x = test();
            // ------ any code following this expression is unreachable 

    let y = 0x64;
            // ^^^^^^^^^^^^^ unreachable statement
    println!("{:?}", y);
}

内存管理概念篇

2021-07-06T00:00:00+00:00

程序如何使用内存

每个程序都需要调用内存才能运行，它们都有各种各样的内存需求。

处于安全性和故障隔离方面的考虑，不允许进程直接访问物理内存，而是使用虚拟内存，操作系统使用被成为页面的内存数据结构映射到实际的物理内存，这些数据结构在页面表中维护。进程必须从操作系统请求内存供其使用，它获得的是一个内存映射到随机存取存储器(Random Access Memory，RAM)物理地址的虚拟地址。

处于性能方面的考虑，内存都以块为单位被请求和处理。当进程访问虚拟内存时，内存管理单元执行从虚拟内存到物理内存的实际转换。

内存管理及其分类

计算机中的RAM是有限资源，并且由所有正在运行的程序共享。当进程完成其指令后，它必须释放所有使用的内存，以便操作系统可以回收内存，并将内存交给其他进程使用。

直到20世纪90年代中期，大多数编程语言都依赖于手动内存管理，这需要程序员分别调用内存分配器API(例如malloc和free)代码来分配和释放内存。大约在1959年，Lisp的创建者John McCarthy发明了GC，这是一种自动内存管理机制，Lisp是第一种采用它的语言。作为运行程序的一部分，GC以守护线程的形式出现，并分析程序中不在引用内存的任何变量，然后在某个时间点在运行程序的同时自动释放它们。

低级语言不附带GC，因为这会引入不确定性和运行时开销，GC线程在后台运行，在某些情况下会暂停程序的运行。这种暂停有时会出现几毫秒的延迟。这可能违反了系统软件在时间和空间上的硬性约束。低级语言要求程序员可以手动控制内存管理。但是，像C++和Rust这样的语言通过类型系统抽象(如智能指针)使程序员能够减轻一些负担。

基于语言之间的差异，我们可以将它们采用的内存管理策略大致分为3类:

手动型: C语言采用了这种内存管理机制，且完全由程序员负责，在程序代码使用完内存之后，调用 free 函数来释放内存。C++在某种程度上使用智能指针自动执行此操作，其中 free 函数调用放在类的析构函数定义中。Rust也有智能指针。
自动型: 采用这种内存管理形式的语言包括一个额外运行时线程，即GC，它作为守护线程与程序一起运行。自动化内存管理是使用这些语言编写代码很容易的原因之一。
半自动型: Swift等语言属于这一类别。它们没有作为运行时的一部分的内置专用GC，但提供了引用计数类型，这可以细粒度地实现自动化内存管理。Rust也提供了引用计数 Rc<T> 和 Arc<T>

内存分配

程序运行时，进程中的内存分配即可能发生在 stack 上，也可能发生在 heap 上。

stack用于处理在编译期已知大小的短期值，这是函数调用及其关联上下文的理想存储位置，一旦函数返回，它就需要被清理掉
heap用于处理任何需要超出函数调用范围的内容

Rust偏向于使用stack内存。通常，你创建并绑定到变量的任何类型的值或实例都会存储到stack中。存储到heap上是显式的，可以通过智能指针类型来实现。

stack

无论何时调用函数或方法，stack都用于为函数内部创建的值分配空间。函数中的所有 let 绑定都存储在stack中，它既可以是值本身，也可以是指向heap内存地址的指针。这些值构成了活动函数的堆栈帧，堆栈帧是stack存储器的逻辑块，用于存储函数调用的上下文。该上下文可能包括函数参数、局部变量、返回地址，以及从函数返回需要恢复的任何易保存的寄存器值。随着越来越多的函数被调用，它们对应的堆栈帧会被压入stack。一旦函数返回，与之相关的堆栈帧，以及其中声明的所有值都会一起被清理释放。

这些值会根据它们声明的相反顺序删除，并且遵循后进先出(Last In First Out, LIFO)规则。

stack内存分配速度很快，因为分配和释放内存只需要一条CPU指令：递增/递减堆栈帧指针。堆栈帧指针(esp)是一个CPU寄存器，它始终指向stack的最顶端。堆栈帧指针在函数被调用或返回时实时更新。当函数返回时，通过将堆栈帧指针恢复到进入函数之前的位置丢弃该堆栈帧。使用stack是一种临时性内存分配策略，但由于其简单性，它在释放已使用内存方面是可靠的。但是，stack的相同属性不适用于超出当前堆栈帧生命周期的情况。

fn double_of(b: i32) -> i32 {
    let x = 2 * b;
    x
}

fn main() {
    let a = 12;
    let result = double_of(a);
}

heap

heap用于处理更复杂的动态的内存分配需求。程序可能在某个时点在heap上分配内存，并且可能在某个其他时点释放，同时这些时点之间不存在严格的边界，就像stack一样。在stack上分配内存时，你能够确定分配和释放内存的时机。此外，heap中的值可能存活得比分配给它的函数更久，稍后也可能会被其他函数清理、释放。在这种情况下，代码无法调用 free 函数，因此最糟糕的情况可能是根本无法取消分配。

不同语言使用堆内存的方式也不尽相同。在C++中，为了避免手动调用 delete 函数，程序员经常使用诸如 unique_ptr 或 shared_ptr这样的智能指针类型。这些智能指针类型具有析构方法，当它们超出内部作用域时，会调用delete函数。这种管理内存的范式被称为RAII原则，并由C++推而广之。

Rust对C++管理堆内存的机制也提供了类似的抽象。Rust在heap上分配内存的唯一方法是通过智能指针类型。Rust中的智能指针实现了Drop特征，它指定了如何释放值所使用的的内存，并且在语义上定义了类似C++中析构函数的方法。

为了在heap上分配内存，语言依赖于专用得内存分配器。编译器rustc自身会采用jemalloc内存分配器，从而rust构建的库和二进制文件会使用系统内存分配器。在Linux上，依赖的将是glibc内存分配器的API。jemalloc是一个支持多线程环境的高效内存分配器库，它大大减少了Rust程序的构建时间。虽然编译器采用了jemalloc，但是任何使用Rust构建的应用程序都不会使用它，因为它会增加二进制文件的大小。因此，已编译的二进制文件和库默认情况下都采用系统内存分配器。

Rust还有一个可插拔的分配器设计，可以使用系统内存分配器，或实现std::alloc模块下的GlobalAlloc特征的自定义内存分配器。

在Rust中，大部分事先不知道尺寸的动态类型都在heap上分配内存。不过这不包括基元类型。

let s = String::new("foo");

String::new 会在heap上分配一个 Vec<u8>类型，并返回对它的引用。此引用会和变量s绑定，该变量在stack上分配内存。只要 s 在作用域内，heap中的字符串就一直存在。当 s 超出其作用域时，Vec<u8>将会从heap释放，其 drop 方法将作为 Drop 实现的一部分进行调用。对于需要在heap上为基元类型分配内存的极个别情况，可以使用 Box<T> 类型，它是一种泛型智能指针类型。

内存安全性

内存安全性是指你的程序永远不会访问它不应该访问的位置，程序中声明的变量不能指向无效内存，并且在所有代码路径中保持有效。换句话说，安全性基本上会归结为在程序中始终具有有效引用的指针，并且使用指针的操作不会导致未定义的行为。未定义的行为指程序的状态出现了编译器未考虑到的情况，因为编译器规范中没有说明在该情况下会发生什么。

内存安全性Bug会导致内存泄漏，以分段错误的形式导致程序崩溃，或者在最糟糕的情况下产生安全漏洞。要在C语言中创建正确且安全的程序，程序员必须在使用完内存后进行适当的free函数调用。如今的C++通过智能指针类型来处理与手动内存管理有关的问题，但这并不能完全消除它们。基于虚拟机的语言(JVM是最典型的例子)使用垃圾收集器来消除所有和类有关的内存安全问题。虽然Rust没有内置GC，但由于该语言中采用了相同的RAII原则，同时根据变量的作用域为我们自动释放使用过的内存，因此比C/C++更安全。它为我们提供了几个细粒度的抽象，用户可以根据自己的需要进行选择。

内存安全三原则

Rust能够在编译期检测程序中内存安全违规，在离开作用域时自动释放相关资源等情况。我们将这些概念称作所有权、借用和生命周期。

所有权有点儿类似核心原则，而借用和生命周期是对语言类型系统的扩展。在代码的不同上下文中加强或有时放松所有权原则，可确保编译器内存管理正常运作。

所有权、借用和生命周期详情，请参考所有权章节详细查看。

为什么使用Rust？

2021-07-02T00:00:00+00:00

为什么使用Rust？

我们都是人，我们的注意力是有限的，我们的记忆是不稳定的–换句话说，我们容易犯错。

计算机和软件无处不在：在太空、地面、海洋、甚至我们的身体中。每天都有越来越多的系统实现自动化，越来越多的人依赖软件(高稳定性、高质量)。

航空电子设备、自动驾驶汽车、核电站、交通控制系统、植入式心脏起搏器等。此类系统中的错误几乎总是危机人类生命。

「通过测试检查程序正确性」和「逻辑证明程序正确性」之间存在着巨大差异。不幸的是，即使我们对代码的每一样都进行了测试，我们仍然无法确定它是否正确。

Rust优势

「Rust作为一种编程语言」的不同之处，学习Rust不是因为它花哨的语法或热情的社区，而是因为人们在用它便携程序时获的的信心。Rust非常严格和严谨的编译器检查您使用的每个变量以及您引用的每个内存地址 。看起来它会影响您编写效率、富有表现力的代码，但令人惊讶的是，恰恰相反：编写一个有效且惯用的Rust程序实际上比编写潜在漏洞的程序更容易 。

在后一种情况下，您将与编译器冲突，因为您的每个操作都可能导致内存安全漏洞。

talk-konstanz-may-2018

上图右侧显示了并发性和内存安相关的问题，这些问题根源上不可能发生在常规(非unsafe)Rust代码中。所以，只需要换成Rust，他们就可以杜绝这段时间内一大半的Bug，因为它们会导致机密泄漏、拒绝服务和远程代码执行漏洞。

Linux 内核是由业内顶级的 5% 中的佼佼者编写的，然而每年仍然可以在CVE(CVE是国际著名的安全漏洞库)中发现50多个安全漏洞。当然，与数百万行代码相比，这 50 个错误微不足道。但是，生死问题，还记得吗？当我们谈论关键系统时，即使是微小的错误也可能导致灾难性的后果。更不用说这 50 个是发现的错误，谁知道还有多少没有被发现的？ 如果使用Rust，我们会在编译发现这些问题 。

运行速度优势

现在编程语言中的 内存安全伴随着垃圾回收的成本 ，并发通常通过同步原子性锁定所受影响的数据结构和执行路径进行解决。对于Rust来说，并不会采用运行时GC这种方式保证内存安全，Rust在编译时就解决了这些问题。

在C++中，只需要为使用的内存负责。例如，在Rust中，只有在绝对需要时才使用Mutex，而且Rust编译器会强制你使用它，所以你永远不会忘记添加它。而这一切基本上都是零成本的。由于大多数检查是在编译器执行的，因此编译后的程序与C或C++编译器生成的程序集没有太大区别。正因为如此，Rust现在在嵌入式电子、物联网，甚至操作系统开发领域都非常有前途 – 以前由于高控制要求和严格的资源和性能限制，这些领域由C主导。

Rust最新版本甚至为用户空间带来了SIMD支持。之前，由于API稳定性限制，它仅在beta版本中可用。现在，你可以通过直接使用向量指令或使用方便的lib库来释放硬件的潜力

rust所有权转移-引用和借用

2021-07-01T00:00:00+00:00

引用和借用

引用(reference)不获取所有权，坚持单一所有者和单一职责，解决了共享访问障碍。按引用传递对象的方式称作借用(borrow)，这比转移所有权更有效。

fn main() {
    let a = 100;
    let r: &i32 = &a;          // &T: 不可变引用。

    assert_eq!(*r, a);
}

fn main() {
    let mut a = 100;
    let r: &mut i32 = &mut a;  // &mut T: 可变引用。
    *r += 1;

    assert_eq!(*r, 101);
}

实现

引用的底层实现和指针基本一致，也就是说附加于引用身上的规则是编译器需要处理的。

两者区别在于：

引用必须有效。引用失效前，目标必须存活且不可改变。
而指针未必，可能是空指针、野指针或悬垂指针。

fn main() {
    let mut a = 0;
    let _r = &mut a;
}

// /root/rs/closure/src/main.rs:
fn main() {
    0x0000555555559200 <+0>:    sub    rsp,0x10

    // let mut a = 0;
    0x0000555555559204 <+4>:    mov    DWORD PTR [rsp+0x4],0x0

    // let _r = &mut a;
    0x000055555555920c <+12>:   lea    rax,[rsp+0x4]                // 引用就是一个指针传递
    0x0000555555559211 <+17>:   mov    QWORD PTR [rsp+0x8],rax

    // }
=> 0x0000555555559216 <+22>:    add    rsp,0x10
   0x000055555555921a <+26>:    ret
End of assembler dump.

引用不获取所有权，也不关心释放。

fn test(s: &mut String) {
    s.push_str("!!!") ;
}

fn main() {
    let mut s = String::from("hello");
    test(&mut s);
}

; /root/rs/closure/src/main.rs:
    // fn main() {
    0x000055555555ada0 <+0>:    sub    rsp,0x28
    0x000055555555ada4 <+4>:    lea    rax,[rip+0x332c1]        # 0x55555558e06c

    // let mut s = String::from("hello");
    0x000055555555adab <+11>:   mov    rdi,rsp
    0x000055555555adae <+14>:   mov    rsi,rax
    0x000055555555adb1 <+17>:   mov    edx,0x5
    0x000055555555adb6 <+22>:   call   0x55555555c8c0 <<alloc::string::String as core::convert::From<&str>>::from>
    0x000055555555adbb <+27>:   mov    rdi,rsp

    // test(&mut s);
 => 0x000055555555adbe <+30>:   call   0x55555555ad80 <closure::test>
    0x000055555555adc3 <+35>:   jmp    0x55555555adc5 <closure::main+37>

    // }
    0x000055555555adc5 <+37>:   mov    rdi,rsp
    0x000055555555adc8 <+40>:   call   0x55555555bc80 <core::ptr::drop_in_place>                ; 引用不获取所有权
    0x000055555555adcd <+45>:   add    rsp,0x28
    0x000055555555add1 <+49>:   ret
    0x000055555555add2 <+50>:   mov    rdi,rsp
    0x000055555555add5 <+53>:   call   0x55555555bc80 <core::ptr::drop_in_place>

    // fn main() {
    0x000055555555adda <+58>:   mov    rdi,QWORD PTR [rsp+0x18]
    0x000055555555addf <+63>:   call   0x555555559050 <_Unwind_Resume@plt>
    0x000055555555ade4 <+68>:   ud2
    0x000055555555ade6 <+70>:   mov    QWORD PTR [rsp+0x18],rax
    0x000055555555adeb <+75>:   mov    DWORD PTR [rsp+0x20],edx
    0x000055555555adef <+79>:   jmp    0x55555555add2 <closure::main+50>


// 作为s参数传入,并不会发生所有权转移

// Dump of assembler code for function closure::test:
// /root/rs/closure/src/main.rs:

//   fn test(s: &mut String) {
 => 0x000055555555ad80 <+0>:    push   rax
    0x000055555555ad81 <+1>:    lea    rax,[rip+0x332e1]        # 0x55555558e069
    0x000055555555ad88 <+8>:    mov    QWORD PTR [rsp],rdi

    // s.push_str("!!!");
    0x000055555555ad8c <+12>:   mov    rsi,rax
    0x000055555555ad8f <+15>:   mov    edx,0x3
    0x000055555555ad94 <+20>:   call   0x55555555c860 <alloc::string::String::push_str>

    // }
    0x000055555555ad99 <+25>:   pop    rax
    0x000055555555ad9a <+26>:   ret

引用和指针区别

区分引用和原始指针(raw pointer)的区别。

引用声明也用 &T，指针 *T 。

fn main() {
    // reference
    let mut x = 100;
    let r : &mut i32 = &mut x;

    *r += 1;
    println!("{:?}", *r);

    // raw-pointer
    let mut y = 200;
    let p: *mut i32 = &mut y;

    unsafe {                        // 指针需要使用unsafe进行操作
        *p += 1;
        println!("{:?}", *p);
    }
}

规则

引用与指针最大的区别在于附加以下的规则，这些需要编译器作出检查。

借用不得超过所有者有效范围(socpe)。
既定时间，只有一个可变引用(&mut T)，或只有多个不可变引用(&T)。
可变引用(&mut T)失效(超出范围或不再使用)前，不能访问原变量。
引用失效(超出范围或不再使用)前，原变量冻结(freeze)，不可修改，转移或重新赋值。

可以按下面的逻辑理解：

只能有一个主人(owner)。
其他人可以租借：
- 同一时刻，可以有多个人(含主人)读(&T)。
- 同一时刻，只能有一个写(&mut T)，其它租客和主人都不能掺合。
- 只要有租借，主人就不得修改、销毁(drop)、转卖(move)或更换(重赋值)。

值有效范围。

fn main() {
    let y: &i32;

    {
        let x = 5;
        y = &x;
            // ^^ borrowed value does not live long enough
    }
    // - `x` dropped here while still borrowed

    println!("{}", y);
}

变量冻结

在借用未失效的情况下，改变原绑定，会导致不一致行为。

这与其他语言有很大的区别。

fn main() {
    let mut s = String::from("abc");
    let r = &s;
            // -- immutable borrow occurs here

     // 引用未失效，不能修改
    s.push_str("def");             
            // ^^^^^^^^^^^^^^^^^ mutable borrow occurs here

    println!("{:?}", r);
            // - immutable borrow later used here
}

fn main() {
    let mut a = 1;

    // 或 &mut a
    let r = &a;            
            // -- borrow of `a` occurs here

    // 引用未失效，不能重新赋值
    a = 50;                 
            // ^^^^^^ assignment to borrowed `a` occurs here

    println!("{}", r);
                   // - borrow later used here
}

fn main() {
    let mut a = 1;
    let r = &a;             // 或&mut a

    println!("{}", r);      // 后续不再使用

    a = 50;                 // OK!
}

同一时刻，不能同时有可变和不可变借用。

fn main() {
    let mut x = 1;
    let r = &mut x;

    println!("{}{}", x, r);
                     // ^  - mutable borrow later used here
                     // |
                     // immutable borrow occurs here
}

fn main() {
    let mut x = 5;
    let r = &mut x;

    *r += 1;

    println!("{}", x);
                   // ^ immutable borrow occurs here 
    println!("{}", *r);
                   // -- mutable borrow later used here
}

fn main() {
    let mut x = 5;
    
    {
        let r = &mut x;
        *r += 1;
        println!("{}", *r);
    }                           // 可变借用结束

    println!("{}", x);
}

同一时刻，只能有一个可写。

fn main() {
    let mut x = 1;
    let r1 = &mut x;
             // ------ first mutable borrow occurs here
    let r2 = &mut x;
             // ^^^^^^ second mutable borrow occurs here

    println!("{}{}", r1, r2);
            // -- first borrow later used here
}

值可变和引用自身可变的区别。

和指针一样，引用自身也是一个对象，有存储空间。

调试器或反汇编，看到引用与指针一样.

fn main() {
    let mut x = 100;
    let r = &mut x;             // 值可变，let r: &mut i32 = &mut x;
    *r += 1;
    
    assert_eq!(*r, 101);
}

fn main() {
    let x = 100;
    let y = 200;

    let mut r = &x;             // 引用自身可变。 let mut r: &i32 = &x;
    assert_eq!(*r, x);

    r = &y;                     // 引用绑定新对象
    assert_eq!(*r, y);
}

rust数据-字符串

2021-06-30T00:00:00+00:00

字符串(UTF-8)相关类型，根据用途选用。

char: 字符，对应Unicode码点。
str: 字符串切片([u8]), 动态尺寸类型(DST)。
String: 堆分配可变字符串(Vec<u8>)。

使用建议

字面量无法修改，直接对应&str。
要动态修改的字符串使用String。
返回子串，不想获取所有权，不想复制内容，用&str或&mut str。

结构示意图

    String               heap
   +=======+           +=========//========+
   | ptr   | --------> | u8 data ...       |
   +-------+           +=========//========+
   | cap   |
   +-------+
   | len   |
   +=======+
  

    &str
   +=======+           +========//========+
   | ptr   | --------> | u8 data ....     |
   +-------+           +========//========+
   | len   |
   +=======+
   

struct String {
  vec: Vec<u8> {
    buf: RawVec<u8> {
      ptr,
      cap,
    },
      len,
    }
}

struct &str {
  ptr: *mut u8,
  len: usize,
}

struct &mut str {
  ptr: *mut u8,
  len: usize,
}

字面量

静态分配(.rodata)。

跨行: 支持跨行。若以\结尾，则删除换行和前置空格。
转义: abc, \x41 \u{6211}们 \" \\
原始字符串(raw string): r"a\x41bc"，r#"a"bc"#(内容包含引号)，r##"a#"bc##(内容包含#, 用更多的##作边界)

// 字面量
let s: &'static str = "hello, world!";

(gdb) p/x &s
$4 = 0x7fffffffe3a8

// 变量s数据存储在0x000055555558c000位置，即.rodata section
(gdb) x/xg &s                                                           
0x7fffffffe3a8:	0x000055555558c000

(gdb) info proc  mappings
0x555555559000     0x55555558c000    0x33000     0x5000 /root/rs/ddd/target/debug/ddd

(gdb) x/16xb 0x000055555558c000                                         // 底层具体存储
0x55555558c000:	0x68	0x65	0x6c	0x6c	0x6f	0x2c	0x20	0x77
0x55555558c008:	0x6f	0x72	0x6c	0x64	0x0a	0x00	0x00	0x00

rust编译器会将换行的 \、空格 符号删除。

fn main() {
    // 字面量
    let s = "foo\
             bar";

    println!("{:?}", s);
    assert_eq!("foobar", s);
}

字节数组

添加b前缀，表示Byte String，同样支持转移、跨行和原始字符串(rb)。但也意味着，只能是ASCII字符，无法容纳Unicode字符。

fn main() {
    let s = b"abc";
    assert_eq!(s, &[b'a', b'b', b'c']);
}

(gdb) info locals
s = 0x55555558b000 b"abc"                   // abc存储位置: 0x55555558b000，即.rodata

(gdb) info proc mappings
0x555555559000     0x55555558b000    0x32000     0x5000 /root/rs/ddd/target/debug/ddd

(gdb) x/3xb 0x55555558b000                  // 具体存储内容 -> 'abc'
0x55555558b000:	0x61	0x62	0x63

转换

根据需要，在不同类型间转换。

字面量转字符串

// literal -> string, heap_alloc

fn main() {
    let mut s = 1.to_string();

    let mut s = "abc".to_string();

    let mut s = String::from("abc");

    println!("{:?}", s);
}

反汇编:

// let mut s = 1.to_string();

(gdb) info locals
s = alloc::string::String {
  vec: alloc::vec::Vec<u8, alloc::alloc::Global> {
    buf: alloc::raw_vec::RawVec<u8, alloc::alloc::Global> {
      ptr: core::ptr::unique::Unique<u8> {
        pointer: 0x5555555a59d0 "1\000",
        _marker: core::marker::PhantomData<u8>
      },
      cap: 8,
      alloc: alloc::alloc::Global
    },
    len: 1
  }
}

(gdb) info proc mappings                                                // "1"被分配在heap上
0x5555555a5000     0x5555555c6000    0x21000        0x0 [heap]

(gdb) x/xg 0x5555555a59d0
0x5555555a59d0:	0x0000000000000031                                      // ASCII 31 -> 1


// let mut s = "abc".to_string();
(gdb) info locals
s = alloc::string::String {
  vec: alloc::vec::Vec<u8, alloc::alloc::Global> {
    buf: alloc::raw_vec::RawVec<u8, alloc::alloc::Global> {
      ptr: core::ptr::unique::Unique<u8> {
        pointer: 0x5555555a59f0 "abc\000",                              // "abc"被分配在heap上 
        _marker: core::marker::PhantomData<u8>
      },
      cap: 3,
      alloc: alloc::alloc::Global
    },
    len: 3
  }
}

(gdb) x/3xb 0x5555555a59f0
0x5555555a59f0:	0x61	0x62	0x63

// let mut s = String::from("abc");
(gdb) info locals
s = alloc::string::String {
  vec: alloc::vec::Vec<u8, alloc::alloc::Global> {
    buf: alloc::raw_vec::RawVec<u8, alloc::alloc::Global> {
      ptr: core::ptr::unique::Unique<u8> {
        pointer: 0x5555555a5a10 "abc\000",                              // "abc"被分配在heap上 
        _marker: core::marker::PhantomData<u8>
      },
      cap: 3,
      alloc: alloc::alloc::Global
    },
    len: 3
  }
}

(gdb) x/3xb 0x5555555a5a10
0x5555555a5a10:	0x61	0x62	0x63

String 转 &str

// let x: &str = &s;
(gdb) ptype x
type = struct &str {
  data_ptr: *mut u8,
  length: usize,
}

(gdb) p/x &x                                // 变量x内存地址(stack)
$1 = 0x7fffffffe3a8

(gdb) x/xg 0x7fffffffe3a8
0x7fffffffe3a8:	0x000055555559f9d0          // 变量x指针地址(heap)

(gdb) x/xg 0x7fffffffe3a8+0x8               // 字符串在heap长度
0x7fffffffe3b0:	0x0000000000000003

(gdb) x/3xb 0x000055555559f9d0              // 字符串内容
0x55555559f9d0:	0x61	0x62	0x63


// let y: &mut str = &mut s;
(gdb) ptype y
type = struct &mut str {
  data_ptr: *mut u8,
  length: usize,
}

(gdb) info locals
y = &mut str {
  data_ptr: 0x55555559f9d0 "abc\000",       // 变量y指针地址(heap)
  length: 3
}

(gdb) x/3xb 0x55555559f9d0                  // 字符串内容
0x55555559f9d0:	0x61	0x62	0x63

String 转 Unicode Char

fn main() {
    let s = "我们".to_string();

    let c = s.chars();
    let s2 = c.as_str();

    assert_eq!(s, s2);
}

操作

格式化字符串

// format

fn main() {
    let s = format!("{}{}", "a", 1);

    assert_eq!(s, "a1");
}

链接字符串

fn main() {
    let v = ["a", "b", "cd"];
    assert_eq!(v.concat(), "abcd");
    assert_eq!(v.join(","), "a,b,cd");
}

rust数据-切片

2021-06-29T00:00:00+00:00

切片(slice,[T])引用序列对象片段，没有所有权。动态尺寸类型(DST，dynamically sized type)，无法直接使用，只能通过指针(&[T])进行。

A type with a size that is known only at run-time is called a dynamically sized type (DST) or, informally, an unsized type. Slices and trait objects are two examples of DSTs.

数组：[T; size] vs &[T]切片

因为[T]长度在编译期间无法确认，所以只能通过固定长度的“指针”定义。

所谓&[T]切片指针，本质上是一个结构体，包含指针和长度信息。

fn main() {
    let v = [1, 2, 3];              // array
    // let s: &[i32] = &v[...];     // slice

    let s = v[..];                  // 不支持直接操作切片,需要通过slice pointer进行操作
       //  ^ doesn't have a size known at compile-time
       // note: all local variables must have a statically known size
}

当操作动态尺寸(DST)类型数据时，只能通过指针进行操作，不能直接操作。

数据结构示意图

// 反汇编

s = &[i32] {
  data_ptr: 0x7fffffffe394,
  length: 3
}

(gdb) x/3xw 0x7fffffffe394
0x7fffffffe394:	0x00000001	0x00000002	0x00000003

   &[T]
  +=====+             +=======//=======+
  | ptr | ----------> | data ...       |
  +-----+             +=======//=======+
  | len |
  +=====+

struct &[T] {
    data_ptr: *mut T,
    length: usize,
}

切片类型

&T: shared slice。
&mut [T]: mutable slice，通过指针修改slice元素
Box<[T]>: boxed slice，装箱堆上分配

构造

从已有序列对象，以起始和结束索引进行构造。

[..]: [0, len -1]
[0..2]: [0, 2]
[0..=2]: [0, 2]
[3..]: [3, len-1]
[..3]: [0, 3]
[..=3]: [0, 3]

&v[..]的实际操作是&(v[..])。

[T]是切片；&[T]是通过”指针”访问切片。

fn main() {
    let v = vec![0, 1, 2, 3];

    let s = &v[..];                     // [0, 3]
    assert_eq!([0, 1, 2, 3], s);

    let s = &v[0..2];                   // [0, 2)
    assert_eq!([0, 1], s);

    let s = &v[0..=2];                  // [0, 2]
    assert_eq!([0, 1, 2], s);

    let s = &v[..2];                    // [0, 2)
    assert_eq!([0, 1], s);

    lset s = &v[..=2];                  // [0, 2]
    assert_eq!([0, 1, 2], s);

    let s = &v[2..];
    assert_eq!([2, 3], s);              // [2, 3]
}

类型转换

注意区别数组引用和切片，虽然可以强制转换。

fn type_of<T>(_: &T) -> &'static str {
    std::any::type_name::<T>()
}

fn main() {
    let s = &[1, 2, 3];
    assert_eq!("&[i32; 3]", type_of(&s));       // array reference

    let s = &[1, 2, 3][..];
    assert_eq!("&[i32]", type_of(&s));          // slice

    let s: &[i32] = &[1, 2, 3];                 // convert
    assert_eq!("&[i32]", type_of(&s));          // slice

    let s = &["one", "two"][..];                // slice
    assert_eq!("&[&str]", type_of(&s));
}

use std::convert::TryFrom;

fn type_of<T>(_: &T) -> &'static str {
    std::any::type_name::<T>()
}

fn main() {
    let a = &[1, 2, 3];
    let s = &a[..];

    assert_eq!("&[i32; 3]", type_of(&a));       // array
    assert_eq!("&[i32]", type_of(&s));          // slice

    // === convert =====================================

    let s2: &[i32] = &[1, 2, 3];                // array2slice
    assert_eq!("&[i32]", type_of(&s));

    let a2 = <&[i32; 3]>::try_from(s2);         // slice2array
    assert_eq!("&[i32; 3]", type_of(&a2.unwrap()));

    println!("{:?}", &a2);
}

操作

通过可变切片间接修改数据源。

⚠️ 切片索引与数据源索引未必一致。

fn main() {
    let mut v = vec![0, 1, 2, 3];
    
    let s = &mut v[2..];
    s[0] += 100;                        // 使用slice的切片索引修改原vec数据

    assert_eq!(v, [0, 1, 102, 3]);
}

反汇编:

s = &mut [i32] {                                            // slice
  data_ptr: 0x55555559f9d8,
  length: 2
}

v = alloc::vec::Vec<i32, alloc::alloc::Global> {            // vec
  buf: alloc::raw_vec::RawVec<i32, alloc::alloc::Global> {
    ptr: core::ptr::unique::Unique<i32> {
      pointer: 0x55555559f9d0,
      _marker: core::marker::PhantomData<i32>
    },
    cap: 4,
    alloc: alloc::alloc::Global
  },
  len: 4
}

遍历(修改)切片

fn main() {
    let s = &mut[1, 2, 3][..];

    for x in s.iter_mut() {
        *x += 100;
    }

    for x in s.iter() {
        println!("{:?}", x);
    }

    println!("{:?}", s);
}

源码实现:

// core/src/slice/mod.rs:723
// 循环遍历获取slice元素

#[inline]
pub fn iter_mut(&mut self) -> IterMut<'_, T> {
    IterMut::new(self)
}

impl<'a, T> IterMut<'a, T> {
    pub(super) fn new(slice: &'a mut [T]) -> Self {
        let ptr = slice.as_mut_ptr();

        unsafe {
            // 检查是否ZST类型
            let end = if mem::size_of::<T>() == 0 {
                // ptr指针不变
                (ptr as *mut u8).wrapping_add(slice.len()) as *mut T
            } else {
                // ptr指针后移
                ptr.add(slice.len())
            };

            // end: 检查迭代器是否完成
            // 依次移动ptr指针位置，直到遍历完成
            Self { ptr: NonNull::new_unchecked(ptr), end, _marker: PhantomData }
        }
    }

    // ...
}

pub fn iter(&self) -> Iter<'_, T> {
    Iter::new(self)
}

impl<'a, T> Iter<'a, T> {
    pub(super) fn new(slice: &'a [T]) -> Self {
        let ptr = slice.as_ptr();
        unsafe {
            let end = if mem::size_of::<T>() == 0 {
                (ptr as *const u8).wrapping_add(slice.len()) as *const T
            } else {
                ptr.add(slice.len())
            };

            Self { ptr: NonNull::new_unchecked(ptr as *mut T), end, _marker: PhantomData }
        }
    }
}

DST: Dynamic Sized Type缩写，动态大小类型。该类型在编译阶段无法确定大小的类型。

ZST: Zero Sized Type缩写，0大小类型。

切片relice操作

fn main() {
    let mut a = [1, 2, 3];

    let s = &mut a[..];
    let s2 = &mut s[1..];

    s2[1] += 100;

    println!("{:?}", s);
    println!("{:?}", a);
}

重新切片受目标slice范围限制，而非底层数组。

fn main() {
    let mut a = [1, 2, 3, 4, 5, 6];

    let s  = &mut a[..3];
    let s2 = &mut s[1..4];
}

$>  cargo r
   Compiling ddd v0.1.0 (/root/rs/ddd)
    Finished dev [unoptimized + debuginfo] target(s) in 2.93s
     Running `/root/rs/ddd/target/debug/ddd`
thread 'main' panicked at 'range end index 4 out of range for slice of length 3', src/main.rs:7:19
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

rust并发-线程

2021-06-28T00:00:00+00:00

并发体系由标准库，而非语言提供支持。这意味着，可能有很多不同的产品可供选择。标准库以1:1系统线程来提供并发支持，使用方式和其他语言类似。

use std::thread;

fn main() {
    let handler = thread::spawn(|| {    // 生成一个新的线程, 返回一个 JoinHandle
        for i in 1..10 {
            println!("{}", i);
        }
    });

    handler.join().unwrap();            // join等待子线程执行完成。
                                        // unwrap() 输出具体值
}

JoinHandle

spawn函数会返回一个JoinHandle类型的值，我们将其存放在变量handler中。这种类型是自线程的句柄，可用于连接线程 – 换句话说就是等待它的终止。如果我们忽略线程的JoinHandle类型,就没有办法等待线程。继续解析我们的代码，从main函数退出之前的子线程上调用join方法。

join

调用Join会阻塞当前线程，并在执行join调用之后的任何代码行之前等待子线程完成。它返回一个Result值。由于我们知道这个线程没有发生panic，可以调用expect方法获取Result中的字符串。如果一个线程正在连接自身或者遇到死锁，那么连接线程可能会失败。在这种情况下，它会返回一个Err变量，其值会传递给处理错误的panic!宏，不过这种情况下返回的值是Any类型，必须将其转换为适当的类型。

自定义类型

我们还可以通过设置其属性(名称或堆栈大小)来配置线程的API。

use std::thread;

fn main() {
    // Builder: 线程工程，可用于配置新线程属性.
    // new(): 生成线程基本配置
    let builder = thread::Builder::new().name("name".into()).stack_size(20 * 1024);

    let handler = builder.spawn(|| {
        for i in 1..10 {
            println!("{}", i);
        }
    }).unwrap();

    handler.join().unwrap();
}

Builder源码实现

Builder 线程工厂源码实现：

pub struct Builder {
    // 线程名称，目前仅用于出现panic时，区分线程名称.
    name: Option<String>,

    // 线程Stack大小 
    stack_size: Option<usize>,
}

线程名称

使用name()函数设置线程名称，目前该线程名称仅用于panic时，用于识别线程名称。

use std::thread;

fn main() {
    let child = thread::Builder::new().name("David".into()).stack_size(20 * 1024);

    let handler = child.spawn(|| {
        panic!("Err");
    }).unwrap();

    handler.join().unwrap();
}

thread 'David' panicked at 'Erro', src/main.rs:11:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: Any', src/main.rs:14:20
root@8d75790f92f5:~/rs/ddd/src# cat main.rs

闭包函数返回值

接收闭包函数返回值。

use std::thread;

fn main() {
    let handler = thread::spawn(|| {
        100
    });

    assert_eq!(handler.join().unwrap(), 100);
}

鉴于不同线程生命周期的差异，强制转移环境变量所有权。

fn main() {
    let data = vec![1, 2, 3, 4];

    let handler = thread::spawn(move || {
        data.iter().for_each(|d| println!("{:?}", d));
    });

    handler.join().unwrap();
}

雪松的博客(专注于Golang、Rust、分布式架构、DB)

Go1.18调度器-内核函数

内核函数

gopark, goready

notesleep

Futex

Go1.18调度器-标准库函数

标准库函数

runtime.Gosched

runtime.Goexit

Go1.18调度器-内核调用

mcall

systemstack

gogo

Go1.18调度器-任务调度

调度

调度器-schedule

中断

锁定

Go1.18 调度器执行源码剖析

执行

结束

KMP字符串查找算法

KMP(Knuth-Morris-Pratt)字符串查找算法

KMP原理

具体代码

Go1.18 调度器-G队列

队列

本地

全局

偷窃

Go1.18 调度器-G复用

复用

获取

放回

Go1.18 调度器-G任务

编号

Go1.18 泛型

generic(泛型)

约束(constraint)

any

comparable

custom

衍生类型(~)

源码剖析

实例代码

Go 泛型实现

GCShape

字典(.dict)

模板(go.shape.{type}_{number})

代码片段

rust 切片

数据结构示意图

切片类型

构造

类型转换

操作

遍历(修改)切片

源码实现:

切片relice操作

rust指针

原始指针

引用和指针互相转换

usize指针转换

智能指针

Drop

Deref 和 DerefMut

智能指针分类

Box

Box创建数组类型

Box类型所有权

递归类型定义

引用计数的智能指针

Rc

弱引用

循环引用问题

单链表实例

双向链表实例

自动解引用

内部可变性

衍生类型(`~`)

字典(`.dict`)

模板(`go.shape.{type}_{number}`)