Wie man richtig mit sync.Cond?

OP beantwortet seine eigene, aber nicht direkt die Antwort auf die ursprüngliche Frage, ich werde posten, wie man richtig mit sync.Cond.

Die Sie nicht wirklich brauchen sync.Cond wenn Sie eine goroutine für jeden der schreiben und Lesen - eine einzige sync.Mutex ausreichen würde, um die Kommunikation zwischen Ihnen. sync.Cond könnte nützlich in Situationen, in denen mehrere Leser warten auf die gemeinsam genutzten Ressourcen zur Verfügung stehen.

var sharedRsc = make(map[string]interface{})
func main() {
    var wg sync.WaitGroup
    wg.Add(2)
    m := sync.Mutex{}
    c := sync.NewCond(&m)
    go func() {
        //this go routine wait for changes to the sharedRsc
        c.L.Lock()
        for len(sharedRsc) == 0 {
            c.Wait()
        }
        fmt.Println(sharedRsc["rsc1"])
        c.L.Unlock()
        wg.Done()
    }()

    go func() {
        //this go routine wait for changes to the sharedRsc
        c.L.Lock()
        for len(sharedRsc) == 0 {
            c.Wait()
        }
        fmt.Println(sharedRsc["rsc2"])
        c.L.Unlock()
        wg.Done()
    }()

    //this one writes changes to sharedRsc
    c.L.Lock()
    sharedRsc["rsc1"] = "foo"
    sharedRsc["rsc2"] = "bar"
    c.Broadcast()
    c.L.Unlock()
    wg.Wait()
}

Spielplatz

Gesagt, dass die Nutzung von Kanälen ist immer noch die empfohlene Methode zum übergeben von Daten um, wenn die situation es zulässt.

Hinweis: sync.WaitGroup hier nur verwendet, um zu warten, bis die goroutines auf Ihre Ausführungen.

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    m := sync.Mutex{}
    m.Lock() //main gouroutine is owner of lock
    c := sync.NewCond(&m)
    go func() {
        m.Lock() //obtain a lock
        defer m.Unlock()
        fmt.Println("3. goroutine is owner of lock")
        time.Sleep(2 * time.Second) //long computing - because you are the owner, you can change state variable(s)
        c.Broadcast()               //State has been changed, publish it to waiting goroutines
        fmt.Println("4. goroutine will release lock soon (deffered Unlock")
    }()
    fmt.Println("1. main goroutine is owner of lock")
    time.Sleep(1 * time.Second) //initialization
    fmt.Println("2. main goroutine is still lockek")
    c.Wait() //Wait temporarily release a mutex during wating and give opportunity to other goroutines to change the state.
    //Because you don't know, whether this is state, that you are waiting for, is usually called in loop.
    m.Unlock()
    fmt.Println("Done")
}

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

Sieht aus wie Sie c.Warten auf Sendung, das wäre nie passiert mit Ihren Abständen.
Mit

time.Sleep(3 * time.Second) //Broadcast after any Wait for it
c.Broadcast()

das snippet scheint zu funktionieren http://play.golang.org/p/OE8aP4i6gY .Oder bin ich etwas fehlt, dass Sie versuchen zu erreichen?

Ja, Sie können mit einem Kanal zum Header übergeben, um mehrere Go-Routinen.

headerChan := make(chan http.Header)

go func() { //This routine can be started many times
    header := <-headerChan  //Wait for header
    //Do things with the header
}()

//Feed the header to all waiting go routines
for more := true; more; {
    select {
    case headerChan <- r.Header:
    default: more = false
    }
}