• slice（切片）：底層資料結構是陣列
• stack（棧）：一種先進後出的資料結構

普通版的模擬寫入和讀取的棧

package main

import "fmt"

//棧的特點是先進後出
//使用一個切片的全域性變數來模擬棧
var stack []int

//向棧中新增資料
func push(value int) {
    stack = append(stack, value)
}

//從棧中獲取資料
func pop() (int, bool) {
    ok := false
    value := 0
    if len(stack) > 0 {
        value 
 
= stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        ok = true
        return value, ok
    } else {
        return value, ok
    }
}

func main() {
    //向棧中新增資料
    for i := 0; i < 10; i++ {
        push(i)
        fmt.Println(stack)
    }
    //從棧中獲取資料
    for {
        v, ok := pop()
        
 
if ok {
            fmt.Println(v)
        } else {
            break
        }
    }
}

使用goroutine來非同步讀取棧中資料或往棧中寫入資料

package main

import (
    "fmt"
)

//棧的特點是先進後出
//使用一個切片的全域性變數來模擬棧
var stack1 []int

//此通道用於通知主協程已經完成操作了
//但是此操作有可能不會輸出全部資料
//因為新增資料和獲取資料是非同步的
//當獲取資料的速度快於寫入資料
//便不會輸出全部資料
var e chan int
 
 = make(chan int)

//向棧中新增資料
func push1(value int) {
    stack1 = append(stack1, value)
    fmt.Println(stack1)
}

//從棧中獲取資料
func pop1() {
    for {
        if len(stack1) > 0 {
            value := stack1[len(stack1)-1]
            stack1 = stack1[:len(stack1)-1]
            fmt.Println(value)
        } else {
            e <- 0
        }
    }
}

func main() {
    for i := 0; i < 10; i++ {
        go push1(i)
    }

    go pop1()

    <-e
}

輸出：

[1]
[1 6 5 9 3 2 7 0 4]
[1 6 5 9 3 2 7 0 4 8]
[1 6 5]
[1 6]
[1 6 5 9 3 2 7 0]
[1 6 5 9]
[1 6 5 9 3 2]
[1 6 5 9 3 2 7]
8
4
0
7
2
3
9
5
6
1
[1 6 5 9 3]

使用goroutine非同步讀取或者寫入的時一定要注意通道的寫法，很容易造成死鎖