golang channel 怎么判斷是否讀取完成(2)？

需求是判斷p是否滿足p=a^2+b^2+c^2

package main

import (
    "fmt"
    "math"
)

func abcasync(p int) bool {
    na := int(math.Sqrt(float64(p))) + 2
    channel := make(chan bool)
    for a := 0; a < na; a++ {
        for b := 0; b < na; b++ {
            go func() {
                for c := 0; c < na; c++ {
                    if a*a+b*b+c*c == p {
                        channel <- true
                    }
                }
            }()

        }
    }
    return <-channel
}

func main() {
    // d := abcasync(41)
    d := abcasync(23)
    fmt.Println(d)
}

這里要求，一旦滿足if條件，就退出程序，以避免浪費計算時間，否則就要遍歷所有的情況。那么，如何判斷所有的協(xié)程都執(zhí)行完了呢？
會報錯，請教如何解決？

回答

編輯回答

尋仙

package main

import (
    "fmt"
    "math"
    "runtime"
    "sync"
)

type S struct {
    a int
    b int
    c int
    p int
}

func NewS(pa, pb, pc, pp int) *S {
    return &S{
        a: pa,
        b: pb,
        c: pc,
        p: pp,
    }
}

func (s *S) isMatch() bool {
    return s.a*s.a+s.b*s.b+s.c*s.c == s.p
}

func abcasync(ch chan *S, chResult chan *S, p int) *S {
    na := int(math.Sqrt(float64(p))) + 2
    for a := 0; a < na; a++ {
        for b := 0; b < na; b++ {
            for c := 0; c < na; c++ {
                select {
                case r := <-chResult:
                    close(ch)
                    return r
                default:
                    ch <- (NewS(a, b, c, p))
                }
            }
        }
    }
    return nil
}

func main() {
    pNum := runtime.NumCPU()
    ch := make(chan *S, 100)
    chResult := make(chan *S)

    var wg sync.WaitGroup
    wg.Add(pNum)
    for i := 0; i < pNum; i++ {
        go func() {
            defer wg.Done()
            for s := range ch {
                if s.isMatch() {
                    chResult <- s
                }
            }
        }()
    }
    d := abcasync(ch, chResult, 10000)
    if d == nil {
        fmt.Println("not found")
    } else {
        fmt.Println(d)
    }
    wg.Wait()
}

計算密集型的，攜程多了不管用，你可以增加協(xié)程數(shù)benchmark一下

2017年2月5日 11:52

編輯回答

涼汐

package main

import (
    "fmt"
    "math"
    "sync"
    "sync/atomic"
)

func abcasync(p int) bool {
    na := int(math.Sqrt(float64(p))) + 2
    var waiteRet sync.WaitGroup
    var find int32 = 0
loop:
    for a := 0; a < na; a++ {
        for b := 0; b < na; b++ {
            if find == 1 {
                break loop
            }
            waiteRet.Add(1)
            go func(a, b int) {
                defer waiteRet.Done()
                for c := 0; c < na; c++ {
                    if find == 1 {
                        break
                    }
                    if a*a+b*b+c*c == p {
                        if atomic.CompareAndSwapInt32(&find, 0, 1) {
                            fmt.Println(a, b, c)
                            break
                        }
                    }
                }
            }(a, b)

        }
    }
    waiteRet.Wait()
    return atomic.LoadInt32(&find) == 1
}

應(yīng)該能滿足你的需求，中間beak判斷沒有使用atomic。使用chan，找不到的情況下會死鎖啊哥哥...還有很多重復計算...

2017年11月5日 13:42