据我所知,如果他们太忙,goroutines会阻止其他goroutines运行.对我来说,这意味着我的应用程序的性能和响应性可能取决于我知道哪些库方法将控制其他goroutine(例如通常是Read()和Write())
有什么方法我可以确切地知道不同的库方法将如何控制其他goroutine,即实际上没有阻止？
有没有办法可以实现一个调用第三方代码的新方法(包括依赖于waitforsingleobject或waitformultipleobjects的异步Win32 API,如findnextchangenotification),并且对Go调度程序表现"不错"？在这个特定的例子中,系统调用将在完成后发出信号,我需要等到它完成后不会耗尽所有其他goroutine.
是否还有另一个"最佳实践",如何处理Go中的第三方阻止操作,以便它们不会耗尽其他goroutines？
我假设Go运行时可能在后台线程上内部运行某种IO循环,以便"暂停"阻止goroutine操作,直到它们完成IO.如果情况确实如此,那么我认为能够在此基础上进行新的阻塞操作可能是有用的.
我正在尝试用goroutines编写一个简单的工作池.
work_channel？码:
package main
import (
"fmt"
"math/rand"
"sync"
"time"
)
func worker(id string, work string, o chan string, wg *sync.WaitGroup) {
defer wg.Done()
sleepMs := rand.Intn(1000)
fmt.Printf("worker '%s' received: '%s', sleep %dms\n", id, work, sleepMs)
time.Sleep(time.Duration(sleepMs) * time.Millisecond)
o <- work + fmt.Sprintf("-%dms", sleepMs)
}
func main() {
var work_channel = make(chan string)
var results_channel = make(chan string)
// create goroutine per item in work_channel
go func() {
var c = 0
var wg …已经厌倦了这个人为的例子:
package main
import "fmt"
func printElo() {
fmt.Printf("Elo\n")
}
func printHello() {
fmt.Printf("Hello\n")
}
func main() {
fmt.Printf("This will print.")
i := 0
for i < 10 {
go printElo()
go printHello()
i++
}
}
这个程序的输出只是"这将打印".输出goroutine printElo()并且printHello不会被发出因为,我猜,main()函数线程将在goroutines甚至有机会开始执行之前完成.
在Golang中使类似代码工作而不是过早终止的惯用方法是什么？
我是Go的新手,在理解并发和通道方面遇到了问题.
package main
import "fmt"
func display(msg string, c chan bool){
fmt.Println("display first message:", msg)
c <- true
}
func sum(c chan bool){
sum := 0
for i:=0; i < 10000000000; i++ {
sum++
}
fmt.Println(sum)
c <- true
}
func main(){
c := make(chan bool)
go display("hello", c)
go sum(c)
<-c
}
该计划的输出是:
display first message: hello
10000000000
但我认为它应该只有一行:
display first message: hello
所以在main函数中,<-c阻塞它并等待另外两个rountines将数据发送到通道.一旦主函数从c接收数据,它就应该继续并退出.
显示和总和同时运行,总和需要更长时间,因此显示应该发送真实到c并且程序应该在总结完成之前退出...
我不确定我是否理解清楚.有人可以帮我吗？谢谢!
我的问题很简单.
我应该将GoRoutines用于一个非常简单的REST API吗？
我基本上只对数据库执行简单查询,验证会话或执行登录.这些操作是否值得设置GoRoutine？GoRoutines何时有用,我该如何设置它们？
正如我们在go中所知,当goroutine必须执行阻塞调用(例如系统调用)或通过cgo调用C库时,可能会创建一个线程.一些测试代码:
package main
import (
"io/ioutil"
"os"
"runtime"
"strconv"
)
func main() {
runtime.GOMAXPROCS(2)
data, err := ioutil.ReadFile("./55555.log")
if err != nil {
println(err)
return
}
for i := 0; i < 200; i++ {
go func(n int) {
for {
err := ioutil.WriteFile("testxxx"+strconv.Itoa(n), []byte(data), os.ModePerm)
if err != nil {
println(err)
break
}
}
}(i)
}
select {}
}
当我运行它时,它没有创建很多线程.
? =99=[root /root]$ cat /proc/9616/status | grep -i thread
Threads: 5
有任何想法吗？
以下代码运行完全正常:
package main
import (
"fmt"
)
func my_func(c chan int){
fmt.Println(<-c)
}
func main(){
c := make(chan int)
go my_func(c)
c<-3
}
但是,如果我改变
c<-3
至
time.Sleep(time.Second)
c<-3
我的代码没有执行.
我的直觉是main在my_func完成执行之前以某种方式返回,但似乎添加暂停应该没有任何效果.我完全迷失在这个简单的例子上,这里发生了什么？
如果通过Go中的通道发送大型结构,它是否真的在goroutines之间复制？
例如,在下面的代码中,Go实际上会复制goroutines生产者和消费者之间的所有largeStruct数据吗？
package main
import (
"fmt"
"sync"
)
type largeStruct struct {
buf [10000]int
}
func main() {
ch := make(chan largeStruct)
wg := &sync.WaitGroup{}
wg.Add(2)
go consumer(wg, ch)
go producer(wg, ch)
wg.Wait()
}
func producer(wg *sync.WaitGroup, output chan<- largeStruct) {
defer wg.Done()
for i := 0; i < 5; i++ {
fmt.Printf("producer: %d\n", i)
output <- largeStruct{}
}
close(output)
}
func consumer(wg *sync.WaitGroup, input <-chan largeStruct) {
defer wg.Done()
i := 0
LOOP:
for {
select {
case …Go运行时(调度程序,垃圾收集器等)可以使用多少个线程？例如,如果GOMAXPROCS是10,那么运行时将使用多少个内核线程？
我读的理由改变GOMAXPROCS对runtime.NumCPU()围棋1.5.有一句话声称"单个goroutine程序的性能可以通过提高GOMAXPROCS运行时的并行性来提高,特别是垃圾收集器."
我真正的问题是:如果我在具有CPU配额的Docker容器中运行单goroutine程序,那么为了获得最大性能,我需要的逻辑处理器的最小数量是多少.