- xml - AJAX/Jquery XML 解析
- 具有多重继承的 XML 模式
- .net - 枚举序列化 Json 与 XML
- XML 简单类型、简单内容、复杂类型、复杂内容
我可能遗漏了一些东西,或者不理解 Go 如何处理并发(或者我对并发本身的了解),我设计了一些代码来理解多个生产者/消费者。
这是代码:
package main
import (
"fmt"
"time"
// "math/rand"
"sync"
)
var seq uint64 = 0
var generatorChan chan uint64
var requestChan chan uint64
func makeTimestamp() int64 {
return time.Now().UnixNano() / int64(time.Millisecond)
}
func generateStuff(genId int) {
var crap uint64
for {
crap = <-requestChan
// <- requestChan
seq = seq+1
fmt.Println("Gen ", genId, " - From : ", crap, " @", makeTimestamp())
generatorChan <- uint64(seq)
}
}
func concurrentPrint(id int, work *sync.WaitGroup) {
defer work.Done()
for i := 0; i < 5; i++ {
requestChan<-uint64(id)
fmt.Println("Conc", id, ": ", <-generatorChan)
}
}
func main() {
generatorChan = make(chan uint64)
requestChan = make(chan uint64)
var wg sync.WaitGroup
for i := 0; i < 20; i++ {
go generateStuff(i)
}
maximumWorker := 200
wg.Add(maximumWorker)
for i := 0; i < maximumWorker; i++ {
go concurrentPrint(i, &wg)
}
wg.Wait()
}
运行时它会打印(主要是按顺序)从 1 到 1000 的所有数字(200 个消费者每人获得一个数字 5 次)。我原以为有些消费者会打印完全相同的数字,但似乎 requestChan 就像一个屏障一样工作,即使有 20 个 goroutines 服务于 generateStuff通过增加全局变量来生成数字。
一般来说,我对 Go 或并发有什么误解?
我预计会出现类似两个 generateStuff 类型的例程的情况,它们会一起被唤醒并同时增加 seq,从而让两个消费者打印相同的数字 2次。
编辑 playgolang 代码:http://play.golang.org/p/eRzNXjdxtZ
最佳答案
您有多个可以同时运行并同时尝试和发出请求的工作器。由于 requestChan
是无缓冲的,它们都阻塞等待读取器同步并接受它们的请求。
您有多个生成器,它们将通过 requestChan
与请求者同步,产生结果,然后阻塞在未缓冲的 generatorChan
上,直到工作人员读取结果。请注意,它可能是不同的 worker 。
没有额外的同步,所以其他一切都是不确定的。
seq
在任何其他生成器碰巧有机会运行之前。如果只有一个处理器,这甚至很有可能。seq
,从而导致各种问题。一般来说,如果不添加同步来强制执行其中一种行为,您就无法确保其中任何一种行为确实发生。
请注意,数据竞争本身就是另一个不确定性事件。有可能获得任意值、程序崩溃等。假设在竞争条件下该值可能仅因一个或一些此类相对无害的结果而偏离是不安全的。
对于实验,您最好的办法就是启动 GOMAXPROCS
。通过环境变量(例如 env GOMAXPROCS=16 go run foo.go
或 env GOMAXPROCS=16 ./foo
after go build
) 或从您的程序中调用 runtime.GOMAXPROCS(16)
。默认值为 1,这意味着可能会隐藏数据竞争或其他“奇怪”行为。
您还可以通过在不同点添加对 runtime.Gosched
或 time.Sleep
的调用来稍微影响事情。
如果您使用竞争检测器(例如使用 go run -race foo.goo
或 go build -race
),您还可以看到数据竞争。程序不仅应该在退出时显示“发现 1 个数据争用”,而且还应该在首次检测到争用时转储大量带有堆栈跟踪的详细信息。
这是用于实验的代码的“清理”版本:
package main
import (
"log"
"sync"
"sync/atomic"
)
var seq uint64 = 0
var generatorChan = make(chan uint64)
var requestChan = make(chan uint64)
func generator(genID int) {
for reqID := range requestChan {
// If you want to see a data race:
//seq = seq + 1
// Else:
s := atomic.AddUint64(&seq, 1)
log.Printf("Gen: %2d, from %3d", genID, reqID)
generatorChan <- s
}
}
func worker(id int, work *sync.WaitGroup) {
defer work.Done()
for i := 0; i < 5; i++ {
requestChan <- uint64(id)
log.Printf("\t\t\tWorker: %3d got %4d", id, <-generatorChan)
}
}
func main() {
log.SetFlags(log.Lmicroseconds)
const (
numGen = 20
numWorker = 200
)
var wg sync.WaitGroup
for i := 0; i < numGen; i++ {
go generator(i)
}
wg.Add(numWorker)
for i := 0; i < numWorker; i++ {
go worker(i, &wg)
}
wg.Wait()
close(requestChan)
}
Playground (但请注意, Playground 上的时间戳将没有用,调用 runtime.MAXPROCS
可能不会执行任何操作)。进一步注意,playground 缓存结果,因此重新运行完全相同的程序将始终显示相同的输出,您需要进行一些小的更改或只在您自己的机器上运行它。
很多小的变化,比如分流生成器,使用 log
与 fmt
因为前者提供并发保证,消除数据竞争,使输出看起来更好,等等。
关于与多个生产者/多个消费者并发,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/29450820/
kafka的java客户端-生产者 生产者消息发送流程 发送原理 在消息发送的过程中,涉及俩个线程,main线程和sender线程,在main线程中创建一个双端队列RecordAccumulator。
我使用互斥体和条件编写了一个生产者/消费者程序。它使用全局 int 来生成和使用值。有 1 个消费者线程和多个生产者线程。 规则: 当值太小时,消费者会等待。 当值太大时,生产者就会等待。 我的问题是
我有兴趣发现当有多个产品和多个消费者时是否可以在不使用赋值的情况下解决生产者 - 消费者问题,即使用函数式编程风格?如何? Producer-consumer problem 谢谢 最佳答案 是的,您
单个进程中的两个不同线程可以通过读取和/或写入共享一个公共(public)内存位置。 通常,这种(有意的)共享是通过使用 lock 的原子操作来实现的。 x86 上的前缀,对于 lock前缀本身(即非
我正在尝试编写一个简单的生产者-消费者应用程序,在该应用程序中,我需要从文件中读取大块数据(可能很大),并且(出于简单测试目的)只需通过另一个线程将其写入另一个文件中即可。 我尝试了很多在线资源,但是
我已经为kafka(wurstmeister / kafka-docker)构建了一个docker镜像。在docker容器内部,我能够使用内置的shell脚本创建主题,生成消息并使用消息。现在,我正在
我正在尝试模拟关于多线程的生产者-消费者模型。 我们假设要遵守三个规则: 当桶装满产品时,生产者不能将产品添加到桶中。 当桶为空时,消费者无法从桶中获取产品。 生产和消费不能同时进行。换句话说,这两个
我有一个生成器应用程序,可以生成索引(将其存储在某些内存树数据结构中)。消费者应用程序将使用索引来搜索部分匹配。 我不希望消费者 UI 在生产者索引数据时必须阻塞(例如通过某些进度条)。基本上,如果用
我正在尝试为我遇到的排队问题找到解决方案。在典型的场景中,生产者将一些东西放入队列中,而消费者将其取出。如果我们有一个也消费的生产者和一个最初从队列中取出某些内容然后将某些内容(例如结果)放回到队列中
虽然以下是众所周知的话题,但我想请您提供意见。我写了一个小程序如下:所有生产者和消费者都排队。我不明白为什么会这样。什么场景下可以完全阻塞。 让我们考虑一下生产者/消费者正在等待数组上的锁,以及是什么
下面是我用于实现生产者-消费者问题的代码。使用 notifyAll() 一切正常,但是由于性能原因,我想用 notify() 替换所有出现的 notifyAll() >. 我发现通过将 notifyA
我有一个生产者-消费者的基本实现,如下所示: 我的问题是如何使线程数:x ~ y 来提高应用程序性能和负载平衡?有人有关键字或提示吗?预先感谢您! 最佳答案 您应该能够通过 Little's La
我编写了一个类“Producer”,它连续解析特定文件夹中的文件。解析的结果将存储在Consumer的队列中。 public class Producer extends Thread { p
我遇到“生产者 - 消费者任务”中可能出现死锁的问题。一切都应该按以下方式进行: 生产者应该生成 int[] 数组并将其添加到集合中 消费者应该获取这些数组,将它们放入第二个集合并在输出中打印 在 D
我正在为我的操作系统类(class)做一个 CPU 调度模拟器项目。该程序应包含两个线程:生产者线程和消费者线程。生产者线程包括在系统中生成进程的生成器和选择多个进程并将它们放入一个名为 Buffer
我想知道是否可以通过 AMQP 和 RabbitMQ 为生产者和消费者使用不同的语言? 例如:Java 用于生产者,python/php 用于消费者,还是反之? 最佳答案 是的,AMQP 与语言无关,
编辑:我有一个生产者类,它将一些数据发送到 SharedBuffer 类。该数据被添加到 ArrayList 中,限制设置为 100。将数据添加到所述列表中没有问题,但消费者类无法从列表中获取任何数据
我正在尝试在有界缓冲区中使用生产者/消费者线程。缓冲区长度为 5。我有 1 个互斥体和 2 个信号量,空信号量从缓冲区大小开始,满信号量从 0 开始。 当我在最后没有 sleep() 的情况下运行代码
关闭。这个问题需要多问focused 。目前不接受答案。 想要改进此问题吗?更新问题,使其仅关注一个问题 editing this post . 已关闭 9 年前。 Improve this ques
我用Java的LinkedBlockingDeque实现了生产者-消费者模式,但我遇到了一个问题,我有时想将一个项目(已经在队列中的某个位置)移动到队列的前面,以便更快地处理它。我永远不知道哪些已经排
我是一名优秀的程序员,十分优秀!