使用golang的slice來模擬棧

• 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異步讀取或者寫入的時一定要注意通道的寫法，很容易造成死鎖