使用无缓冲队列实现java的栅栏效应

main.go

package main

import (
    "fmt"

    "github.com/zhuge20100104/barrier/barrier"
)

func main() {
    b := barrier.NewBarrier(10)

    for i := 0; i < 9; i++ {
        go b.Wait()
    }
    fmt.Println("完事了")
}

barrier/barrier.go

package barrier

import (
    "fmt"
)

// IBarrier 栅栏接口
type IBarrier interface {
    Wait()
}

// Barrier 栅栏类
type Barrier struct {
    chCount chan interface{}
    chSync  chan interface{}
    count   int
}

// NewBarrier 栅栏类的构造函数
func NewBarrier(n int) IBarrier {
    cCount := make(chan interface{})
    cSync := make(chan interface{})
    b := &Barrier{
        chCount: cCount,
        chSync:  cSync,
        count:   n,
    }

    go b.syncCount()
    return b
}

// Wait 栅栏类的等待方法
func (b *Barrier) Wait() {
    b.chCount <- struct{}{}
    // 阻塞读,只有当有数据写入,或者关闭channel时,才会返回
    <-b.chSync
}

// syncCount 统计等待次数的函数
func (b *Barrier) syncCount() {
    count := 0
    for range b.chCount {
        count++
        fmt.Println(count)
        // 说明已经达到了指定个数
        if count >= b.count {
            fmt.Println("跳出")
            close(b.chSync)
            break
        }
    }
}