标签: goroutine

我试图从我创建的结构中打印json结果,如下所示:

type Machine struct {
  m_ip string
  m_type string
  m_serial string
}

并打印出来

m:= &Machine{ m_ip:"test", m_type:"test", m_serial:"test" }
m_json:= json.Marshal(m)
fmt.Println(m_json)

但是,结果返回{}

其次,我尝试将单词的第一个字母改为大写,如下所示:

type Machine struct{
  MachIp string
  MachType string
  MachSerial string
}

它的工作原理!无论如何,为什么前面的小写字母不起作用？

我想用Go从Yahoo finance下载股票价格电子表格.我将为自己的goroutine中的每个股票发出http请求.我有一个大约2500个符号的列表,但不是并行地发出2500个请求,我宁愿一次做250个.在Java中,我创建了一个线程池,并在它们获得空闲时重用它们.我试图找到类似的东西,一个goroutine池,如果你愿意,但无法找到任何资源.如果有人能告诉我如何完成手头的任务或者为我指出相同的资源,我会很感激.谢谢!

我最近开始阅读有关Go编程语言的内容,我发现通道变量是一个非常吸引人的概念.是否可以在Haskell中模拟相同的概念？也许有一个数据类型Channel a和一个monad结构来启用可变状态和函数,就像关键字一样go.

我在并发编程方面不是很擅长,而在Haskell中这样简单的通道传递机制会让我的生活更轻松.

编辑

人们让我澄清了我对转换为Haskell感兴趣的Go模式.所以Go的通道变量是第一类的,可以传递并由函数返回.我可以读取和写入这些通道,因此可以在可以并发运行的例程之间轻松进行通信.Go还有一个go关键字,根据语言规范同时启动函数执行作为独立线程,并继续执行代码而无需等待.

我感兴趣的是确切的模式是这样的(Go的语法很奇怪 - 变量由varName的VARTYPE而不是通常的倒方式声明的 - 但我认为这是可读的):

func generateStep(ch chan int) {
      //ch is a variable of type chan int, which is a channel that comunicate integers
      for {
          ch <- randomInteger() //just sends random integers in the channel 
      }

func filter(input, output chan int) {
      state int
      for {
          step <- input  //reads an int from the input channel
          newstate := update(state, step) //update the variable with some update function …

我目前正在研究Tour of Go,我认为goroutines的使用方式与Python生成器类似,特别是问题66.我认为66看起来很复杂,所以我把它重写为:

package main

import "fmt"

func fibonacci(c chan int) {
    x, y := 1, 1

    for {
        c <- x
        x, y = y, x + y
    }
}

func main() {
    c := make(chan int)
    go fibonacci(c)

    for i := 0; i < 10; i++ {
        fmt.Println(<-c)
    }
}

这似乎有效.几个问题:

1. 如果我将通道上的缓冲区大小调高,比如10,fibonacci将尽快填满10个其他位置,并尽可能快地main消耗掉这些位置.这是正确的吗？这会比以1的缓冲区大小更高的性能而牺牲内存,对吗？
2. 由于频道没有被fibonacci发送者关闭,当我们离开这里的范围时会发生什么？我的期望是,一旦c和go fibonacci超出范围,渠道和它的一切得到垃圾收集.我的直觉告诉我这可能不会发生什么.

我看到很多关于如何使Go等待x个goroutine完成的教程和示例,但我要做的是确保总是有x个数字运行,所以一旦结束就会启动一个新的goroutine .

具体来说,我有几十个'要做的事',它正在处理一些来自MySQL的东西.它的工作原理如下:

db, err := sql.Open("mysql", connection_string)
checkErr(err)
defer db.Close()

rows,err := db.Query(`SELECT id FROM table`)
checkErr(err)
defer rows.Close()

var id uint
for rows.Next() {
    err := rows.Scan(&id)
    checkErr(err)
    go processTheThing(id)
    }
checkErr(err)
rows.Close()

目前,将推出数十万个线程processTheThing().我需要的是启动最多x个数字(我们称之为20个)goroutines.所以它首先为前20行启动20,然后从那时开始,它会在当前goroutine之一完成时为下一个id启动一个新的goroutine.所以在任何时候总有20个跑步.

我确信这是非常简单/标准的,但我似乎无法找到任何教程或示例或如何完成的良好解释.

在GO教程中,我们有这张幻灯片:Goroutines

package main

import (
    "fmt"
    "time"
)

func say(s string) {
    for i := 0; i < 5; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    go say("world")
    say("hello")
}

运行此代码会产生预期的结果("world"和"hello"可互换地写入屏幕5次).

但是,如果我们注释掉time.Sleep(因此,"time"导入的行)并再次运行程序,我们只剩下 "hello"写入屏幕五次.

什么是如此重要time.Sleep才能使goroutine免于死亡？

Go 之间switch和selectGo 之间是否有任何区别,
除了一个参与争论而另一个不参与？

Kotlin corutines是有限状态机和一些任务运行器的糖(例如,默认的ForkJoinPool).https://github.com/Kotlin/kotlin-coroutines/blob/master/kotlin-coroutines-informal.md#implementation-details

换句话说,java/kotlin运行时中还没有运行时协同程序(但这可以随http://cr.openjdk.java.net/~rpressler/loom/Loom-Proposal.html而改变).Kotlin协程只是连续执行的任务,它们是逐个执行的.每个任务都可以在线程池的任何线程中执行.

Go运行时支持"协同程序".但是goroutines并不是真正的协同程序.Goroutines不允许在程序中设置屈服点.此外,Go不允许设置自定义线程池.您只能在默认池中设置线程大小.

kotlin协同程序和goroutine之间的第一个区别是Go运行时管理此时正在运行的协同程序.当goroutine在某些IO操作(或同步原语)被阻塞时,请选择下一个Job来执行它.在JVM中,没有这种术语的智能工作转换.

因此,Go可以廉价地改变当前正在运行的工作.Go只需改变一些注册表https://groups.google.com/forum/#!msg/golang-nuts/j51G7ieoKh4/wxNaKkFEfvcJ.但也有人说,JVM可以使用堆栈线程而不是使用寄存器.因此根本没有保存和加载寄存器.

kotlin协程和goroutines之间的第二个区别是协同程序的类型.Kotlin协同程序是无堆栈协程.Goroutines是堆栈协程.Kotlin协程的所有状态都存储在Kotlin上下文中,该上下文存储在堆中.Goroutines状态存储在寄存器和线程堆栈中.

我想知道,哪些协程(goroutines和kotlin协程)在IO绑定任务中更快？CPU绑定任务？内存消耗怎么样？

我有并发的goroutine想要将(指向a)指针结构附加到同一个切片.你如何在Go中编写它以使其兼容并发？

这将是我使用等待组的并发不安全代码:

var wg sync.WaitGroup
MySlice = make([]*MyStruct)
for _, param := range params {
    wg.Add(1)
    go func(param string) {
        defer wg.Done()
        OneOfMyStructs := getMyStruct(param)
        MySlice = append(MySlice, &OneOfMyStructs)
    }(param)
}
wg.Wait()

我想你需要使用go渠道来实现并发安全.任何人都可以贡献一个例子吗？

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

package main

import "fmt"

var battle = make(chan string)

func warrior(name string, done chan struct{}) {
    select {
    case opponent := <-battle:
        fmt.Printf("%s beat %s\n", name, opponent)
    case battle <- name:
        // I lost :-(
    }
    done <- struct{}{}
}

func main() {
    done := make(chan struct{})
    langs := []string{"Go", "C", "C++", "Java", "Perl", "Python"}
    for _, l := range langs { go warrior(l, done) }
    for _ = range langs { <-done }
}

[第1个问题]

 done <- struct{}{} …