如何正确并行化2个函数并捕获错误？

时间：2018-02-05 14:23:44

标签： go

我练习golang而且我不知道如何捕捉错误。

我的期望：

  1. FetchTickerData运行
  2. 它同时调用2个不同的函数：fetchPriceTicket和fetchWhatToMine
  3. 如果其中一个函数返回错误，则FetchTickerData将返回该错误
  4. 如果一切正常，它会从两个来源处理数据并将其返回

    5. 我无法弄清楚如何捕捉错误。我写了这段代码，但我不认为它是正确的解决方案而且它不起作用。有什么更好的方法呢？

    package main

import "net/http"
import (
    "github.com/tidwall/gjson"
    "time"
    "io/ioutil"
    "fmt"
)

var client = &http.Client{Timeout: 10 * time.Second}

type Ticker struct {
}

func FetchTickerData() (error, *gjson.Result, *gjson.Result) {
    whatToMine := make(chan *gjson.Result)
    currency := make(chan *gjson.Result)
    err := make(chan error)
    counter := 0 // This variable indicates if both data was fetched

    go func() {
        innerError, json := fetchWhatToMine()

        fmt.Print(innerError)
        if innerError != nil {
            err <- innerError
            // Stop handler immediately
            whatToMine <- nil
            currency <- nil
            return
        }

        whatToMine <- json
        counter = counter + 1

        if counter == 2 {
            fmt.Print("err pushed")
            err <- nil
        }
    }()

    go func() {
        innerError, json := fetchPriceTicket()
        fmt.Print(innerError)

        if innerError != nil {
            err <- innerError
            whatToMine <- nil
            currency <- nil
            return
        }

        currency <- json
        counter = counter + 1

        if counter == 2 {
            fmt.Print("err pushed")
            err <- nil
        }
    }()

    return <-err, <-whatToMine, <-currency
}

func fetchPriceTicket() (error, *gjson.Result) {
    resp, err := client.Get("https://api.coinmarketcap.com/v1/ticker/")

    if err != nil {
        return err, nil
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    json := gjson.GetBytes(body, "");
    return nil, &json;
}

func fetchWhatToMine() (error, *gjson.Result) {
    resp, err := client.Get("https://whattomine.com/coins.json")

    if err != nil {
        return err, nil
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    json := gjson.GetBytes(body, "");
    return nil, &json;
}

    UPD：如果我将return <-err, <-whatToMine, <-currency替换为return nil, <-whatToMine, <-currency，则会返回我期望的数据，但如果存在，则不会返回错误。

    UPD：还有第二版代码：

    package main

import "net/http"
import (
    "github.com/tidwall/gjson"
    "time"
    "io/ioutil"
    "context"
    "fmt"
)

var client = &http.Client{Timeout: 10 * time.Second}

type Ticker struct {
}

func main() {
    ticker, coins, err := FetchTickerData()

    fmt.Print("Everything is null! ", ticker, coins, err)
    if err != nil {
        fmt.Print(err)
        return
    }
    fmt.Print("Bitcoin price in usd: ", ticker.Array()[0].Get("price_usd"))
}

func FetchTickerData() (*gjson.Result, *gjson.Result, error) {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    var result1, result2 *gjson.Result
    var err1, err2 error

    go func() {
        result1, err1 = fetchJson(ctx, "https://api.coinmarketcap.com/v1/ticker/")
        if err1 != nil {
            cancel() // Abort the context, so the other function can abort early
        }
    }()

    go func() {
        result2, err2 = fetchJson(ctx, "https://whattomine.com/coins.json")
        if err2 != nil {
            cancel() // Abort the context, so the other function can abort early
        }
    }()

    if err1 == context.Canceled || err1 == nil {
        return result1, result2, err2
    }
    return result1, result2, err1
}

func fetchJson(ctx context.Context, url string) (*gjson.Result, error) {
    req, err := http.NewRequest(http.MethodGet, url, nil)
    if err != nil {
        return nil, err
    }

    req = req.WithContext(ctx)
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }
    fmt.Print("I don't know why this body isn't printed ", string(body))
    json := gjson.ParseBytes(body)
    return &json, nil
}

    由于某些原因，http请求在此处无效，并且没有错误。想法？

    Everything is null! <nil> <nil> <nil>panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x11f7843]

goroutine 1 [running]:
main.main()
    /Users/andrey/go/src/tickerUpdater/fetchTicker.go:25 +0x183

2 个答案:

答案 0 :(得分：10)

这是context包的完美用例。我删除了你的一些样板，以及你的第二个功能;你需要将它添加回来为你的实际代码。

func FetchTickerData() (*gjson.Result, *gjson.Result, error) {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    var result1, result2 *gjson.Result
    var err1, err2 error
    var wg sync.WaitGroup

    wg.Add(1)
    go func() {
        defer wg.Done()
        result1, err1 := fetchPriceTicket(ctx)
        if err1 != nil {
            cancel() // Abort the context, so the other function can abort early
        }()
    }

    wg.Add(1)
    go func() {
        defer wg.Done()
        result2, err2 := fetchWhatToMine(ctx)
        if err2 != nil {
            cancel() // Abort the context, so the other function can abort early
        }
    }()

    wg.Wait()

    // if err1 == context.Canceled, that means the second goroutine had
    // an error and aborted the first goroutine, so return err2.
    // If err1 == nil, err2 may still be set, so return it in this case
    // as well.
    if err1 == context.Canceled || err1 == nil {
        return result1, result2, err2
    }
    return result1, result2, err1
}

func fetchPriceTicket(ctx context.Context) (*gjson.Result, error) {
    req, err := http.NewRequest(http.MethodGet, "https://api.coinmarketcap.com/v1/ticker/", nil)
    if err != nil {
        return nil, err
    }

    req = req.WithContext(ctx)
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }
    json := gjson.GetBytes(body, "")
    return &json, nil
}

答案 1 :(得分：4)

由于您不再使用通道，因此主要的例程在其他两个goroutine的执行开始之前完成，因此退出程序。你应该使用waitgroups阻止主要的goroutine，直到其他两个完成他们的工作。

package main

import "net/http"
import (
    "context"
    "fmt"
    "io/ioutil"
    "sync"
    "time"

    "github.com/tidwall/gjson"
)

var client = &http.Client{Timeout: 10 * time.Second}

type Ticker struct {
}

func main() {
    ticker, coins, err := FetchTickerData()

    fmt.Print("Everything is null! ", ticker, coins, err)
    if err != nil {
        fmt.Print(err)
        return
    }
    fmt.Print("Bitcoin price in usd: ", ticker.Array()[0].Get("price_usd"))
}

func FetchTickerData() (*gjson.Result, *gjson.Result, error) {
    var wg sync.WaitGroup
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    var result1, result2 *gjson.Result
    var err1, err2 error

    wg.Add(2)
    go func() {
        defer wg.Done()
        result1, err1 = fetchJson(ctx, "https://api.coinmarketcap.com/v1/ticker/")
        if err1 != nil {
            cancel() // Abort the context, so the other function can abort early
        }
    }()

    go func() {
        defer wg.Done()
        result2, err2 = fetchJson(ctx, "https://whattomine.com/coins.json")
        if err2 != nil {
            cancel() // Abort the context, so the other function can abort early
        }
    }()

    wg.Wait()

    if err1 == context.Canceled || err1 == nil {
        return result1, result2, err2
    }
    return result1, result2, err1
}

func fetchJson(ctx context.Context, url string) (*gjson.Result, error) {
    req, err := http.NewRequest(http.MethodGet, url, nil)
    if err != nil {
        return nil, err
    }

    req = req.WithContext(ctx)
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }
    fmt.Print("I don't know why this body isn't printed ", string(body))
    json := gjson.ParseBytes(body)
    return &json, nil
}
相关问题
最新问题