标签: goroutine

为什么网络i/o的goroutine被阻止?

我在Ubuntu 13.04上使用了1.1开发

go version devel +ebe8bca920ad Wed May 15 15:34:47 2013 +1000 linux/386
Run Code Online (Sandbox Code Playgroud)

根据http://golang.org/doc/faq#goroutines

当协程阻塞时,例如通过调用阻塞系统调用,运行时自动将同一操作系统线程上的其他协同程序移动到另一个可运行的线程,这样它们就不会被阻塞.

我正在尝试编写一个可以使用goroutines下载大块文件的下载器,这是我提出的最好的goroutine:

func download(uri string, chunks chan int, offset int, file *os.file) {
    for current := range chunks {

        fmt.println("downloading range: ", current, "-", current+offset)

        client := &http.client{}
        req, _ := http.newrequest("get", uri, nil)
        req.header.set("range: ", fmt.sprintf("bytes=%d-%d", current, current+offset))
        resp, err := client.do(req)
        if err != nil {
            panic(err)
        }
        defer resp.body.close()
        body, err := ioutil.readall(resp.body)
        if err != nil {
            panic(err)
        } …
Run Code Online (Sandbox Code Playgroud)

go goroutine

3
推荐指数
1
解决办法
1039
查看次数

使用匿名go函数在循环内传递指针会导致仅使用最后一个元素指针

因此,在下面的代码中,我将指向匿名go函数的指针传递给了函数,但代码的行为并不像我期望的那样.

package main

import "fmt"

type (
    Element struct{
        Name string
    }
)

func main() {
    elements := []Element{{"first"}, {"second"}, {"third"}, {"fourth"}}
    waiting := make(chan bool)

    for _, element := range elements {
        go func(element *Element){
            fmt.Println("Element Name: ", element.Name)
            waiting <- true
        }(&element)
    }

    for i := 0; i < 4; i++{
        <- waiting
    }
}
Run Code Online (Sandbox Code Playgroud)

我希望代码写:

  • '第一'
  • '第二'
  • '第三'
  • '第四'

以任何顺序,但它是打印:

  • '第四'
  • '第四'
  • '第四'
  • '第四'

因此,似乎匿名go函数'解析'它的*Element参数到当时该循环中的任何内容,所以这个代码将通过传递Element {}本身而不是指向元素的指针来修复.

我的问题是:

  • 这是定义的行为吗?
  • 我怎么能重写这个接受指向我的元素{}的指针?

操场:

http://play.golang.org/p/tcRvforQE4

编辑:问题格式

pointers go goroutine

3
推荐指数
1
解决办法
309
查看次数

阻止Ctrl + C在Golang中中断exec.Command

我注意到,exec.Command即使通过中断调用中断调用,进程也会中断signal.Notify.我已经完成了以下示例来说明问题:

package main

import (
    "log"
    "os"
    "os/exec"
    "os/signal"
    "syscall"
)

func sleep() {
    log.Println("Sleep start")
    cmd := exec.Command("sleep", "60")
    cmd.Run()
    log.Println("Sleep stop")
}

func main() {
    var doneChannel = make(chan bool)

    go sleep()

    c := make(chan os.Signal, 1)
    signal.Notify(c, os.Interrupt)
    signal.Notify(c, syscall.SIGTERM)
    go func() {
        <-c
        log.Println("Receved Ctrl + C")
    }()

    <-doneChannel
}
Run Code Online (Sandbox Code Playgroud)

如果在此程序运行时按下Ctrl + C,它将打印:

2015/10/16 10:05:50 Sleep start
^C2015/10/16 10:05:52 Receved Ctrl + C
2015/10/16 10:05:52 Sleep stop
Run Code Online (Sandbox Code Playgroud)

显示sleep命令被中断.虽然Ctrl + C已成功捕获并且主程序未退出,但它只是 …

multithreading subprocess go sigint goroutine

3
推荐指数
1
解决办法
1635
查看次数

golang,int类型不支持索引

我在部分代码中遇到了麻烦.我正在写revel框架(要清楚).这是一个工作日常规,我希望它做几件事:

  1. 根据来源,切换stat变量的struct类型.我做了一个开关,但在所有其他代码都正确之前,我真的不知道交换机是否写得正确.

  2. 我获取日期的缓存,并将其放入新的工作项.

  3. 我发送工作到频道

这是我现在得到的:

func worker(in <-chan Task, out chan <- Work, wg *sync.WaitGroup) {

    for t := range in {
        for sourceName, charts := range t.Request.Charts {

            var stat interface{}

            switch sourceName {
            case "noagg":
                 stat = stat.([]NoaggModel)
            case "oracle":
                stat = stat.([]OracleModel)
            default:
                panic("Invalid type for Work model!")
            }

            w := Work{Name:"", Data:""}

            err := cache.Get(string(sourceName)+"_"+string(t.Date), &stat);

            for chart := range charts{
                w.Name = chart["name"]

                if err == nil{
                    w.Data = countDataByName( stat, t.Request.Filters, string(chart["name"]))
                }
                out …
Run Code Online (Sandbox Code Playgroud)

go switch-statement goroutine

3
推荐指数
1
解决办法
3715
查看次数

for-range循环中指针和值切片之间的差异

请检查以下代码段:

package main

import (  
    "fmt"
    "time"
)

type field struct {  
    name string
}

func (p *field) print() {  
    fmt.Println(p.name)
}

func main() {
    fmt.Println("use values:")

    // use values in range loop and go rountines
    values := []field{{"one"},{"two"},{"three"}}
    for _, v := range values {
        go v.print()
    }

    time.Sleep(time.Second)

    fmt.Println()
    fmt.Println("use pointers:")

    // use pointers in range loop and go rountines
    poniters := []*field{{"one"},{"two"},{"three"}}
    for _, v := range poniters {
        go v.print()
    }

    time.Sleep(time.Second)
}
Run Code Online (Sandbox Code Playgroud)

链接到这里:https: …

pointers for-loop go goroutine

3
推荐指数
1
解决办法
300
查看次数

Go - 使用 goroutine 执行 Bash 命令 n 次并存储和打印其结果

我对Golang一般来说还很陌生,我正在尝试执行一个bash command with its arguments n times,然后将 存储Output在一个变量中Print。

我只能做一次,或者loops像下面这样使用:

package main

import (
    "fmt"
    "os/exec"
    "os"
    "sync"
)


func main() {

    //Default Output
    var (
        cmdOut []byte
        err    error
    )

    //Bash Command
    cmd  := "./myCmd"
   //Arguments to get passed to the command
   args := []string{"arg1", "arg2", "arg3"}

    //Execute the Command
    if cmdOut, err = exec.Command(cmd, args...).Output(); err != nil {
        fmt.Fprintln(os.Stderr, "There was an error running "+cmd+" "+args[0]+args[1]+args[2], err)
        os.Exit(1) …
Run Code Online (Sandbox Code Playgroud)

bash go goroutine

3
推荐指数
1
解决办法
4361
查看次数

Golang HTTP 请求工作池

我正在尝试构建一个系统、工作池/作业队列,以http requests在每个 API 端点上尽可能多地处理。我查看了这个示例并让它工作得很好,只是我偶然发现了一个问题,我不明白如何将它扩展pool / jobqueue到不同的端点。

出于场景考虑,让我们绘制一个 Golang http 服务器,它在不同的端点和请求类型GET和POSTETC上有 100 万个请求/分钟。

我如何扩展这个概念?我是否应该为每个端点创建不同的工作池和作业。或者我可以创建不同的作业并将它们输入同一个队列并让相同的池处理这些作业吗?

我想保持简单,如果我创建一个新的 API 端点,我不必创建新的工作池,所以我可以只关注 api。但性能也非常重要。

我正在尝试构建的代码取自前面链接的示例,这里是其他人的 github 'gist' 使用此代码。

api multithreading go goroutine

3
推荐指数
1
解决办法
1万
查看次数

工作池的最佳大小

我正在构建一个 Go 应用程序,它使用 goroutines 的“工作池”,最初我启动池创建许多工作人员。我想知道多核处理器中的最佳工人数量是多少,例如在具有 4 核的 CPU 中?我目前正在使用以下方法:

    // init pool
    numCPUs := runtime.NumCPU()

    runtime.GOMAXPROCS(numCPUs + 1) // numCPUs hot threads + one for async tasks.
    maxWorkers := numCPUs * 4

    jobQueue := make(chan job.Job)

    module := Module{
        Dispatcher: job.NewWorkerPool(maxWorkers),
        JobQueue:   jobQueue,
        Router:     router,
    }

    // A buffered channel that we can send work requests on.
    module.Dispatcher.Run(jobQueue)
Run Code Online (Sandbox Code Playgroud)

完整的实现在下

job.NewWorkerPool(maxWorkers) 和 module.Dispatcher.Run(jobQueue)

我使用工作池的用例:我有一个服务,它接受请求并调用多个外部 API,并将它们的结果聚合到一个响应中。每个调用都可以独立于其他调用,因为结果的顺序无关紧要。我将调用分派到工作池,其中每个调用都以异步方式在一个可用的 goroutine 中完成。一旦工作线程完成,我的“请求”线程就会在获取和聚合结果的同时继续监听返回通道。完成所有操作后,最终聚合结果将作为响应返回。由于每个外部 API 调用可能呈现可变响应时间,因此某些调用可以比其他调用更早完成。

parallel-processing optimization go goroutine worker-pool

3
推荐指数
1
解决办法
3650
查看次数

从不同的线程读取值

我在Go中编写了很多并行计算软件.我想从工作线程收集数据,我不确定如何以安全的方式做到这一点.我知道,我可以用通道,但在我的情况,他们使之更加复杂,因为我必须在主线程同步莫名其妙消息(等到每个线程发送的东西).

脚本

主线程创建n个 Worker实例并work()在goroutine中启动它们的方法,以便每个工作者都在自己的线程中运行.每10秒,主线程应从工作者处收集一些简单值(例如迭代计数)并打印统一统计量.

题

从工人那里读取价值是否安全?主线程只读取值,每个单独的线程将写入自己的值.如果读取时值为几纳秒就可以了.

关于如何以简单的方式实现这一点的任何其他想法?

concurrency multithreading thread-safety go goroutine

3
推荐指数
1
解决办法
171
查看次数

写入两个独立的通道是否可靠顺序?

如果我在两个频道上有一个选择:

for {
    select {
    case <-chan1:
        // do something
    case <-chan2:
        // do something else
    }
}
Run Code Online (Sandbox Code Playgroud)

在一个单独的goroutine中,我按顺序写入这些频道:

chan1 <- "blah"
chan2 <- true
Run Code Online (Sandbox Code Playgroud)

我保证在"做别的事情"之前看到"做某事"吗?

我知道如果有两个未阻塞的通道,select会随机选择,但我认为如果select已经阻塞,写入第一个通道可能会"中断"写入goroutine,这意味着select将在未阻塞的第一个通道上运行第二次写.

channel go goroutine

3
推荐指数
1
解决办法
65
查看次数