Nachrichtenwarteschlange ist ein gängiges Systemarchitekturmuster, das eine äußerst wichtige Rolle bei der Handhabung hoher Parallelität und asynchroner Aufgabenverarbeitung spielt. In der Go-Sprache ist die Verwendung von Nachrichtenwarteschlangen durch einige Open-Source-Nachrichtenwarteschlangenbibliotheken und -tools sehr bequem und einfach geworden.
In diesem Artikel wird die Verwendung von Nachrichtenwarteschlangen in Go vorgestellt, einschließlich der folgenden:
Nachrichtenwarteschlange ist ein Architekturmuster, das Warteschlangen zum Zwischenspeichern, asynchronen Übertragen und Speichern von Nachrichten verwendet. Nachrichtenwarteschlangen sind im Allgemeinen in drei Teile unterteilt: Produzenten, Verbraucher und Warteschlangen. Der Produzent sendet die Nachricht an die Warteschlange und der Verbraucher nimmt die Nachricht zur Verarbeitung aus der Warteschlange. Der Zweck der Nachrichtenwarteschlange besteht darin, die Zeit- und Raumabhängigkeiten zwischen Produzenten und Verbrauchern zu entkoppeln und eine asynchrone Aufgabenverarbeitung zu implementieren.
Die Nachrichtenwarteschlange kann Daten zwischenspeichern, asynchrone Verarbeitung, Spitzenlastausgleich (um viele gleichzeitige Anforderungen in kurzer Zeit zu bewältigen) und Lastausgleich implementieren usw. Sie ist eine wichtige Komponente zur Unterstützung der Entwurf großer verteilter Systeme.
Es gibt viele Nachrichtenwarteschlangenbibliotheken und -tools auf dem Markt, die verschiedene Programmiersprachen unterstützen. Die gebräuchlichsten sind die folgenden:
# 🎜🎜#RabbitMQs AMQP-Client-Bibliothek: https://github.com/streadway/amqp;
RabbitMQ installieren, Download von der offiziellen Website-Adresse: https://www.rabbitmq.com/download.html;
func main() {
spider()
}
func spider() {
url := "https://www.example.com"
doc, _ := goquery.NewDocument(url)
doc.Find(".img_wrapper img").Each(func(i int, s *goquery.Selection) {
imgUrl, _ := s.Attr("src")
publishToMQ(imgUrl)
})
}
func publishToMQ(msg string) {
conn, err := amqp.Dial("amqp://test:test@localhost:5672/test")
failOnError(err, "Failed to connect to RabbitMQ")
defer conn.Close()
ch, err := conn.Channel()
failOnError(err, "Failed to open a channel")
defer ch.Close()
q, err := ch.QueueDeclare(
"image_downloader", // name
true, // durable
false, // delete when unused
false, // exclusive
false, // no-wait
nil, // arguments
)
failOnError(err, "Failed to declare a queue")
err = ch.Publish(
"", // exchange
q.Name, // routing key
false, // mandatory
false, // immediate
amqp.Publishing{
ContentType: "text/plain",
Body: []byte(msg),
})
failOnError(err, "Failed to publish a message")
log.Printf(" [x] Sent %s", msg)
}Dann schreibe den Bild-Downloader. Durch Abhören der Nachrichtenwarteschlange von RabbitMQ wird ein asynchrones Herunterladen von Bildern erreicht:
func main() {
consumeMQ()
}
func consumeMQ() {
conn, err := amqp.Dial("amqp://test:test@localhost:5672/test")
failOnError(err, "Failed to connect to RabbitMQ")
defer conn.Close()
ch, err := conn.Channel()
failOnError(err, "Failed to open a channel")
defer ch.Close()
q, err := ch.QueueDeclare(
"image_downloader", // name
true, // durable
false, // delete when unused
false, // exclusive
false, // no-wait
nil, // arguments
)
failOnError(err, "Failed to declare a queue")
msgs, err := ch.Consume(
q.Name, // queue
"", // consumer
true, // auto-ack
false, // exclusive
false, // no-local
false, // no-wait
nil, // args
)
failOnError(err, "Failed to register a consumer")
forever := make(chan bool)
go func() {
for d := range msgs {
log.Printf("Received a message: %s", d.Body)
downloadImage(string(d.Body))
}
}()
log.Printf(" [*] Waiting for messages. To exit press CTRL+C")
<-forever
}
func downloadImage(url string) {
resp, err := http.Get(url)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
file, err := os.Create(uuid.New().String() + ".jpg")
if err != nil {
log.Fatal(err)
}
defer file.Close()
_, err = io.Copy(file, resp.Body)
if err != nil {
log.Fatal(err)
}
log.Printf("Downloaded an image: %s", url)
}Im obigen Code haben wir eine Arbeitswarteschlange „Bild-Downloader“ erstellt, nachdem der Produzent die Bildadresse des HTML analysiert hat Seite, es geht an die Arbeit Nachrichten in der Warteschlange senden. Der Verbraucher hört die Arbeitswarteschlange ab und ruft nach Erhalt der Nachricht die Funktion downloadImage auf, um die Bilddatei herunterzuladen.
Das obige Beispiel ist ein einfacher Anwendungsfall mit RabbitMQ. Die Verwendung anderer Nachrichtenwarteschlangenbibliotheken ist ähnlich, Sie müssen lediglich Verbindungen und Vorgänge über unterschiedliche APIs implementieren.
Übersicht
In diesem Artikel stellen wir vor und erklären, was eine Nachrichtenwarteschlange ist. In vielen Datenverarbeitungsszenarien ist der asynchrone Verbrauch unerlässlich. Die Go-Sprache macht die asynchrone Aufgabenverarbeitung aufgrund ihres eigenen Coroutine-Mechanismus einfach und effizient. In Verbindung mit den umfangreichen Open-Source-Bibliotheken der Go-Sprache selbst wird es äußerst einfach, Nachrichtenwarteschlangen zur Implementierung einer asynchronen Nachrichtenverarbeitung zu verwenden.
Anhand der obigen Beispiele können wir sehen, dass bei der Implementierung der asynchronen Aufgabenverarbeitung die Verwendung von Nachrichtenwarteschlangen die Verarbeitungseffizienz erheblich verbessern kann und die Verwendung von Nachrichtenwarteschlangen in der Go-Sprache auch sehr praktisch ist. In Projekten wird empfohlen, Open-Source-Nachrichtenwarteschlangenbibliotheken wie RabbitMQ oder Apache Kafka zu verwenden.
Das obige ist der detaillierte Inhalt vonWie verwende ich die Nachrichtenwarteschlange in Go?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Was sind Zeichenkonstanten?
Der Computer friert ein. Der Bildschirm bleibt hängen
Die Rolle von index.html
Was bedeutet OEM?
Wie tippe ich die Inschrift auf dem Münzkreis ein?
So aktualisieren Sie den DNS-Cache
So lösen Sie das Problem, dass Tomcat die Seite nicht anzeigen kann
Ajax-Lösung für verstümmelten chinesischen Code
