Question

我试图学习如何使用频道在Go中为我的其他项目创建一个队列。我的另一个项目基本上将数据库行排队，然后使用行中的详细信息对数据库进行数字运算。

我不希望同时在同一个工作组中处理同一行，因此需要检查一个工作者当前是否正在处理该特定行ID，如果是，请等待它完成。如果它不是相同的行ID，它可以异步运行，但我也想限制可以同时运行的异步工作器的数量。在我下面的代码中，我现在试图将其限制为三名工人。

以下是我所拥有的：

package main

import (
    "log"
    "strconv"
    "time"
)

// RowInfo holds the job info
type RowInfo struct {
    id int
}

// WorkerCount holds how many workers are currently running
var WorkerCount int

// WorkerLocked specifies whether a row ID is currently processing by a worker
var WorkerLocked map[string]bool

// Process the RowInfo
func worker(row RowInfo) {
    rowID := strconv.Itoa(row.id)

    WorkerCount++
    WorkerLocked[rowID] = true

    time.Sleep(1 * time.Second)
    log.Printf("ID rcvd: %d", row.id)

    WorkerLocked[rowID] = false
    WorkerCount--
}

// waiter will check if the row is already processing in a worker
// Block until it finishes completion, then dispatch
func waiter(row RowInfo) {
    rowID := strconv.Itoa(row.id)
    for WorkerLocked[rowID] == true {
        time.Sleep(1 * time.Second)
    }

    go worker(row)
}

func main() {
    jobsQueue := make(chan RowInfo, 10)
    WorkerLocked = make(map[string]bool)

    // Dispatcher waits for jobs on the channel and dispatches to waiter
    go func() {
        // Wait for a job
        for {
            // Only have a max of 3 workers running asynch at a time
            for WorkerCount > 3 {
                time.Sleep(1 * time.Second)
            }

            job := <-jobsQueue
            go waiter(job)
        }
    }()

    // Test the queue, send some data
    for i := 0; i < 12; i++ {
        r := RowInfo{
            id: i,
        }
        jobsQueue <- r
    }

    // Prevent exit!
    for {
        time.Sleep(1 * time.Second)
    }
}

我收到此错误，但这是一个间歇性问题，因为有时当我运行它时似乎有效。是否存在竞争条件？：

go run main.go
panic: runtime error: invalid memory address or nil pointer dereference
[signal 0xb code=0x1 addr=0x8 pc=0x4565e7]

goroutine 37 [running]:
main.worker(0x5)
    /home/piiz/go/src/github.com/zzz/asynch/main.go:25 +0x94
created by main.waiter
    /home/piiz/go/src/github.com/zzz/asynch/main.go:42 +0xbb

goroutine 1 [sleep]:
time.Sleep(0x3b9aca00)
    /usr/local/go/src/runtime/time.go:59 +0xf9
main.main()
    /home/piiz/go/src/github.com/zzz/asynch/main.go:73 +0xf8

goroutine 5 [sleep]:
time.Sleep(0x3b9aca00)
    /usr/local/go/src/runtime/time.go:59 +0xf9
main.main.func1(0xc82008c000)
    /home/piiz/go/src/github.com/zzz/asynch/main.go:55 +0x2d
created by main.main
    /home/piiz/go/src/github.com/zzz/asynch/main.go:61 +0xa0

goroutine 35 [sleep]:
time.Sleep(0x3b9aca00)
    /usr/local/go/src/runtime/time.go:59 +0xf9
main.worker(0x2)
    /home/piiz/go/src/github.com/zzz/asynch/main.go:27 +0xa1
created by main.waiter
    /home/piiz/go/src/github.com/zzz/asynch/main.go:42 +0xbb

goroutine 36 [sleep]:
time.Sleep(0x3b9aca00)
    /usr/local/go/src/runtime/time.go:59 +0xf9
main.worker(0x4)
    /home/piiz/go/src/github.com/zzz/asynch/main.go:27 +0xa1
created by main.waiter
    /home/piiz/go/src/github.com/zzz/asynch/main.go:42 +0xbb

goroutine 34 [sleep]:
time.Sleep(0x3b9aca00)
    /usr/local/go/src/runtime/time.go:59 +0xf9
main.worker(0x1)
    /home/piiz/go/src/github.com/zzz/asynch/main.go:27 +0xa1
created by main.waiter
    /home/piiz/go/src/github.com/zzz/asynch/main.go:42 +0xbb

goroutine 12 [runnable]:
runtime.goexit1()
    /usr/local/go/src/runtime/proc1.go:1732
runtime.goexit()
    /usr/local/go/src/runtime/asm_amd64.s:1697 +0x6
created by main.main.func1
    /home/piiz/go/src/github.com/zzz/asynch/main.go:59 +0x8c

goroutine 19 [sleep]:
time.Sleep(0x3b9aca00)
    /usr/local/go/src/runtime/time.go:59 +0xf9
main.worker(0x8)
    /home/piiz/go/src/github.com/zzz/asynch/main.go:27 +0xa1
created by main.waiter
    /home/piiz/go/src/github.com/zzz/asynch/main.go:42 +0xbb

goroutine 20 [sleep]:
time.Sleep(0x3b9aca00)
    /usr/local/go/src/runtime/time.go:59 +0xf9
main.worker(0x0)
    /home/piiz/go/src/github.com/zzz/asynch/main.go:27 +0xa1
created by main.waiter
    /home/piiz/go/src/github.com/zzz/asynch/main.go:42 +0xbb

goroutine 16 [sleep]:
time.Sleep(0x3b9aca00)
    /usr/local/go/src/runtime/time.go:59 +0xf9
main.worker(0x9)
    /home/piiz/go/src/github.com/zzz/asynch/main.go:27 +0xa1
created by main.waiter
    /home/piiz/go/src/github.com/zzz/asynch/main.go:42 +0xbb

goroutine 33 [sleep]:
time.Sleep(0x3b9aca00)
    /usr/local/go/src/runtime/time.go:59 +0xf9
main.worker(0x3)
    /home/piiz/go/src/github.com/zzz/asynch/main.go:27 +0xa1
created by main.waiter
    /home/piiz/go/src/github.com/zzz/asynch/main.go:42 +0xbb

goroutine 18 [sleep]:
time.Sleep(0x3b9aca00)
    /usr/local/go/src/runtime/time.go:59 +0xf9
main.worker(0x7)
    /home/piiz/go/src/github.com/zzz/asynch/main.go:27 +0xa1
created by main.waiter
    /home/piiz/go/src/github.com/zzz/asynch/main.go:42 +0xbb

goroutine 22 [sleep]:
time.Sleep(0x3b9aca00)
    /usr/local/go/src/runtime/time.go:59 +0xf9
main.worker(0xa)
    /home/piiz/go/src/github.com/zzz/asynch/main.go:27 +0xa1
created by main.waiter
    /home/piiz/go/src/github.com/zzz/asynch/main.go:42 +0xbb

goroutine 49 [runnable]:
main.worker(0x6)
    /home/piiz/go/src/github.com/zzz/asynch/main.go:21
created by main.waiter
    /home/piiz/go/src/github.com/zzz/asynch/main.go:42 +0xbb
exit status 2

无论如何，我还在学习，所以如果你看看我的代码然后去了什么地狱＆＃34;，好吧，我不会感到惊讶:)也许我正在接近这个问题完全错了。感谢。

Answer 1

如果您要使用WorkerLocked地图，则需要使用sync包保护对其的访问权限。您还需要以相同的方式保护WorkerCount（或使用原子操作）。做这样的事情也会使睡眠变得不必要（使用条件变量）。

更好的是，有3个（或多个）工作人员等待行使用频道。然后，您可以将行分发给各个工作程序，以便特定工作人员始终处理特定行（例如，使用row.id％3来确定将行发送到哪个工作人员/通道）。

Answer 2

我强烈建议您不要在这种情况下使用任何锁定，因为您有工作人员处理来自数据库的读取。一般情况下，锁和信号量会导致很多问题，最终会给您带来大量损坏的数据。相信我。去过也做过。你需要小心，避免在这种情况下使用它们。如果您希望保留数据并维护地图（例如但不是用于实际处理），则锁定很有用。

通过锁定常规程序，你不必放慢你的go程序。 Go旨在尽可能快地处理事物。别抱他了。

这是我自己的一些理论，可以帮助你理解我想说的更好一点：

为了处理工作人员限制为3.只生成从队列中选择的3个不同的go例程。工人永远不会从渠道接受相同的工作，所以你在这里安全。
make（）已经完成了内部通道限制，可以很好地用于这种情况。该通道限制是实际的第二个参数。因此，如果您编写
```
queue := make(chan RowInfo, 10)
```
，则表示此队列可以使用最多10个的RowInfo。如果聚合到此队列中的循环达到其中的10个，它将锁定并等待worker从通道释放一个项目。因此，一旦队列转到9，数据库聚合器将写入第10个，而工作人员将取出第10个。

通过这种方式，你可以拥有golang的自然工作流程:)这也称为产生前工作者

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
    "time"
)

// RowInfo holds the job info
type RowInfo struct {
    ID int
}

func worker(queue chan RowInfo, done chan bool) {
    fmt.Println("Starting worker...")

    for {
        select {
        case row := <-queue:
            fmt.Printf("Got row info: %v \n", row)
            // Keep it for second so we can see actual queue lock working
            time.Sleep(1 * time.Second)

        case <-time.After(10 * time.Second):
            fmt.Printf("This job is taking way too long. Let's clean it up now by lets say write write in database that job has failed so it can be restarted again when time is right.")
        case <-done:
            fmt.Printf("Got quit signal... Killing'em all")
            break
        }
    }
}

func handleSigterm(kill chan os.Signal, done chan bool) {
    select {
    case _ = <-kill:
        close(done)
    }
}

func main() {

    // Do not allow more than 10 records to be in the channel.
    queue := make(chan RowInfo, 10)
    done := make(chan bool)

    kill := make(chan os.Signal, 1)

    signal.Notify(kill, os.Interrupt)
    signal.Notify(kill, syscall.SIGTERM)

    go handleSigterm(kill, done)

    for i := 0; i < 3; i++ {
        go worker(queue, done)
    }

    // Should be infinite loop in the end...
    go func() {
        for i := 0; i < 100; i++ {
            fmt.Printf("Queueing: %v \n", i)
            queue <- RowInfo{ID: i}
        }
    }()

    <-done
    // Give it some time to process things before shutting down. This is bad way of doing things
    // but is efficient for this example
    time.Sleep(5 * time.Second)
}

至于管理数据库状态，您可以在数据库中显示“正在进行中”的状态，因此每次选择您时，都会对该行进行更新。这当然是一种方法。通过在golang中保留某种映射，我会说你对服务的折磨超过了它的需要。

希望这有帮助！

去：学习频道＆amp;排队，致命错误

2 个答案: