import "fmt"
func sum(s []int, c chan int) {
sum := 0
for _, v := range s {
sum += v
}
c <- sum // send sum to c
}
func main() {
s := []int{7, 2, 8, -9, 4, 0}
c := make(chan int)
go sum(s[:len(s)/2], c)
go sum(s[len(s)/2:], c)
x, y := <-c,
我正在用一个示例程序打印奇数和偶数和1到100之间的和,使用带有多个通道的goroutine。
你可以找到我的密码
输出
sum of even number = 2550
sum of odd number = 2500
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan receive]:
main.print(0x434100, 0x11db7c)
/tmp/sandbox052575152/main.go:18 +0xc0
main.main()
/tmp/sandbox05257
下面的代码是一个简化的例子:
func printer(c <-chan int) {
for {
fmt.Print(<-c)
}
}
func provide() {
c := make(chan int)
go printer(c)
for i := 1; i <= 100; i++ {
c <- i
}
}
函数provide创建一个go例程printer,用于打印provide生成的数据。
我的问题是,在provide返回并且printer在空通道上开始阻塞之后会发生什么。g
我正在编写一个函数,其中我试图增加一个通道。在一个大得多的程序中,这是不起作用的,它实际上挂在一条看起来像:
current = <-channel
go func正在运行,但程序似乎在这一行上停止运行。
我试图编写一个更小的SSCCE,但现在我遇到了一个不同的问题。下面是:
package main
import (
我想在go中向多个听众发送多个广播。
我无法通过一个通道发送数据,因为除了close信号(标题的第二个“倍数”)之外,只有一个侦听器才能得到数据。
但是,一旦频道关闭,我就不能发送任何其他信号(标题的第一个“倍数”)。
因此,我编写了以下代码(本文末尾的解释):
package main
import "sync"
// Broadcast allows to send a signal to all listeners
type Broadcast struct {
lock sync.RWMutex
ch chan struct{}
}
// Ne
下面给出的pe4Concurrent.go文件是我第一次尝试编写并发程序,pe4.go是相同算法的非并发实现,用于比较。
该算法本身是一个简单的,蛮力的解决方案之一的工程欧拉问题。
基本上,我对Go和并发性都很陌生,希望能就如何提高我在pe4Concurrent.go中使用通道和大猩猩的效率或优雅程度提出任何建议。
非并发蛮力解决方案(为比较目的包括在内):
pe4.go
//Project Euler: Problem 4
//Largest palindrome product
//A palindromic number reads the same both ways. The l
我试图在Go中实现对循环的停止。我现在拥有的代码的灵感来自于这里:
但是,我没有能够让我的代码像预期的那样运行。我的代码从一个复杂的代码库中获得的简化版本如下:
package main
import (
"fmt"
"time"
)
var quit chan struct{}
var send chan int
func quitroutine() {
for {
select {
case cnt := <-send:
fmt.Println(cnt)
我正在尝试理解非缓冲通道,所以我写了一个小应用程序,它迭代用户输入的数组,做一些工作,将信息放在非缓冲通道上,然后读取它。但是,我无法从通道中读取。这是我的代码 toProcess := os.Args[1:]
var wg sync.WaitGroup
results := make(chan string)
errs := make(chan error)
for _, t := range toProcess {
wg.Add(1)
go Worker(t, "text", results, errs, &wg)
}
go func()
我在学围棋。我正在尝试使用信号量来解决goroutines上的死锁问题。我已经创建了两个写入无缓冲通道的函数。读数发生在主频道上。第三个函数用于关闭通道。当我运行程序时,它抛出这个错误致命错误:所有goroutines都处于睡眠状态-死锁!有没有人能跟我解释一下为什么这个没用。
import (
"fmt"
"sync"
)
var wg sync.WaitGroup
var s = []string{"a", "b", "c", "d"}
var w = []string{
我是个新手。在我下面的例子中,多个go例程从一个未缓冲的通道消耗。
代码:
var c = make(chan int)
func f() {
for val := range c {
fmt.Printf("routine 1 : %v\n", val)
}
}
func g() {
fmt.Printf("routine 2 : %v\n", <-c)
}
func main() {
go f()
go g()
c <- 0
c <- 1
c
我试图为大量的文件构建一个解析器,但是我找不到可能被称为“嵌套的goroutines”的信息(也许这不是正确的名称吗?)
有很多文件,每个文件都有很多行。我应该这么做吗?
for file in folder:
go do1
def do1:
for line in file:
go do2
def do2:
do_something
或者我应该只使用“一个级别”的goroutines,并执行以下操作:
for file in folder:
for line in file:
go do_something
我的问题主要针对
所以我正在使用大猩猩websocket库,我正在构建一个websocket服务器,当我收到一个连接时,我创建了2个go例程,一个用来读取来自客户端的传入消息,另一个用来侦听发送到通道的消息,然后将它们发送到客户端。
func (p *Player) EventLoop() {
l4g.Info("Starting player %s event loop", p)
go p.readFromSocket()
go p.writeToSocket()
//blocks until we receive an interrupt from the
我想读取go中的用户输入,而忽略用户试图通过捕获CTRL-C.来扼杀我的进程,我旋转了一个CTRL-C来捕获CTRL-C,并且还写入了一个通道。在这个阶段,我希望控制返回到case <-intr在主要的峡谷,但这是没有发生的。
下面是运行的输出:
$ go run read.go
Enter text: hello
Entered:hello
$go run read.go
Enter text: ^CGot signal interrupt
Exiting signal handler..
Invalid input2
Interrupted.. Continuing
Ente
我有一个go函数,它将在通道接收到一些逻辑后执行一些逻辑。
我的问题是,我希望函数在完成逻辑后仍然有效。我的想法是
我将在函数中添加一个无限的while循环。但是,我想知道这是不是
一种很好的技术。我的代码如下:
func process(channel chan string, sid string) {
inputSid := <-channel
// check if sid exist in process pool
if strings.EqualFold(sid, inputSid) {
fmt.Println("Got me