Gewusst wie: implementieren Sie einen Zähler bei der Verwendung von golang die goroutine?

Ich versuche zu machen ein queue struct, dass die push und pop Funktionen.

Ich 10 threads schieben und weitere 10 threads pop-Daten, nur wie ich in dem code unten.

Fragen :
1. Ich muss ausgedruckt, wie viel ich habe geschoben/aufgetaucht, aber ich weiß nicht, wie das zu tun.
2. Ist es irgendwie beschleunigen mein code ? der code ist zu langsam für mich.

package main

import (
    "runtime"
    "time"
)

const (
    DATA_SIZE_PER_THREAD = 10000000
)

type Queue struct {
    records string
}


func (self Queue) push(record chan interface{}) {
    //need push counter
    record <- time.Now()
}

func (self Queue) pop(record chan interface{}) {
    //need pop counter
    <- record
}

func main() {
    runtime.GOMAXPROCS(runtime.NumCPU())
    //record chan
    record := make(chan interface{},1000000)
    //finish flag chan
    finish := make(chan bool)
    queue := new(Queue)
    for i:=0; i<10; i++ {
        go func() {
            for j:=0; j<DATA_SIZE_PER_THREAD; j++ {
                queue.push(record)
            }
            finish<-true
        }()
    }
    for i:=0; i<10; i++ {
        go func() {
            for j:=0; j<DATA_SIZE_PER_THREAD; j++ {
                queue.pop(record)
            }
            finish<-true
        }()
    }
    for i:=0; i<20; i++ {
        <-finish
    }
}

InformationsquelleAutor MrROY | 2012-09-04

13

Gibt es ein paar Dinge, die Sie beheben sollten.
- Den Methoden, die in der Warteschlange geben sollte-Zeiger-Empfänger. Ansonsten, jede Methode
  rufen Sie erstellt eine Kopie der aktuellen queue-Typ und die änderungen in die Warteschlange Felder
  nicht weiter über die Methode sich selbst aufrufen.
- Warten alle Routinen zu beenden, kann durchgeführt werden, indem ein sync.WaitGroup. Diese
  ist speziell, was es für entworfen wurde.
- Aufrechterhaltung einer thread-sicheren push - /pop-counter innerhalb der queue-Typ kann getan werden, indem
  mit der sync/atomic Paket.
So weit wie Geschwindigkeit geht, aus deinem Beispiel bin ich mir nicht ganz sicher, was Sie versuchen zu erreichen. Alle Verbesserungen kommen könnte, wenn du das nochmal ein wenig.

Hier ist ein Beispiel, das ich geändert, aus dem code:
```
package main

import (
    "log"
    "runtime"
    "sync"
    "sync/atomic"
    "time"
)

const SizePerThread = 10000000

type Queue struct {
    records string
    count   int64
}

func (q *Queue) push(record chan interface{}) {
    record <- time.Now()

    newcount := atomic.AddInt64(&q.count, 1)
    log.Printf("Push: %d", newcount)
}

func (q *Queue) pop(record chan interface{}) {
    <-record

    newcount := atomic.AddInt64(&q.count, -1)
    log.Printf("Pop: %d", newcount)
}

func main() {
    var wg sync.WaitGroup

    runtime.GOMAXPROCS(runtime.NumCPU())

    record := make(chan interface{}, 1000000)
    queue := new(Queue)

    //We are launching 20 goroutines.
    //Let the waitgroup know it should wait for as many
    //of them to finish.
    wg.Add(20)

    for i := 0; i < 10; i++ {
        go func() {
            defer wg.Done()

            for j := 0; j < SizePerThread; j++ {
                queue.push(record)
            }
        }()

        go func() {
            defer wg.Done()

            for j := 0; j < SizePerThread; j++ {
                queue.pop(record)
            }
        }()
    }

    //Wait for all goroutines to finish.
    wg.Wait()
}
```
- Danke @jimt, ich bin mir aber nicht ganz verstehen, was du meinst mit die Warteschlange geben sollte-Zeiger-Empfänger, könnten Sie mir einen link auf golang doc? ich kann nicht finden, nochmals vielen Dank.
- Dieser Abschnitt der Effektiven Gehen Sie erläutert den Unterschied: golang.org/doc/effective_go.html#pointers_vs_values. Im wesentlichen, wenn der Empfänger (T), Ihre Methode wird ein kopieren von der Objekt er aufgerufen wird und deshalb nicht geändert werden. Wenn der Empfänger (*T) es wird ein Zeiger darauf.
- In Fällen, In denen die Anzahl von go-Routinen ist streng genommen nicht zur Kompilierzeit bekannt ist, gibt es aus irgendeinem Grund nicht aufrufen wg.Add(1) defer.wg.Done() in jeder erstellt goroutine?
- Überhaupt keinen Grund. Ich verwendet einen einzigen Aufruf von Add (), da die Anzahl von Routinen, die bekannt waren, bevor die hand, und war somit in der Lage zu reduzieren die Menge der notwendigen Funktionsaufrufe.
- Vielleicht sollte ich revidiere meinen Kommentar. Aufruf wg.Add(1) in jede goroutine ist im Prinzip machbar. Es sollte aber beachtet werden, dass es keine Garantie dafür, dass die goroutine wird für die Ausführung geplant werden, bevor der Aufruf von thread erreicht, die wg.Wait() Teil. In einigen seltenen Fällen könnte dies bedeuten, dass die WaitGroup counter wurde noch nicht erhöht, und der Aufruf von wg.Wait() vorzeitig abgeschlossen. Dies stellt eine race-Bedingung und sollten daher vermieden werden. Sie können sicher aufrufen wg.Add(1) Recht, vor dem starten einer bestimmten goroutine obwohl.
InformationsquelleAutor jimt
-5

Antwort zu Frage 1: Wie jimt vorgeschlagen, sync/atomic-Funktionen für atomar Aktualisierung eines Zählers, die für Sie nützlich sein kann.

Antwort zu Frage 2: Verringern Sie den Wert, der DATA_SIZE_PER_THREAD, oder besser noch, verwenden Sie das Programm
```
package main
func main() {}
```
produziert die gleiche Ausgabe wie das Programm in ein effektiver Weg.

Aber im ernst, ich verstehe Sie geschrieben haben, ein kleines Programm zu erkunden, einige Konzepte. Ihr Programm enthält eine Reihe von Fragen allerdings. Dies ist nicht die Zeit sich sorgen zu machen über die Geschwindigkeit, es ist die Zeit zu lernen, einige grundlegende Konzepte.
- Nicht eine hilfreiche Antwort an alle.
InformationsquelleAutor Sonia

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.