Konkurrenz und Parallelität: Ist Golang in dieser Hinsicht besser als Java?

Einer der Hauptvorteile von Golang (oder Go), einer von Google entwickelten Sprache, ist das Wettbewerbsmanagement, also die Möglichkeit, mehrere Aufgaben gleichzeitig auszuführen.

Jede moderne Sprache verfügt über Tools zum Umgang mit Parallelität. Was Go auszeichnet, ist, dass die Laufzeit die meisten Details zu Threads und Parallelität für uns abstrahiert, was diese Verarbeitung viel einfacher macht. Es ist die Laufzeit, nicht der Betriebssystemkernel, die definiert, wie Goroutinen Betriebssystem-Threads zugewiesen werden und wie die Threads mit den verfügbaren CPU-Kernen interagieren.

Der Entwickler kann Parallelität (verschachtelte Ausführung) und Parallelität (gleichzeitige Ausführung) gleichzeitig in Go verwenden. Und er kann dies sogar explizit tun, indem er die GOMAXPROCS-Eigenschaft bestimmt, die die Grenze für gleichzeitige Threads im Programm darstellt. So kann Go Goroutinen auf mehreren Kernen abbilden, um echte Parallelität und Maschinen mit dieser Architektur in der Verarbeitung zu erhalten. Standardmäßig erledigt die Laufzeit diese Abstraktion jedoch bereits für uns.

import (
    "runtime"
)

func main() {
    runtime.GOMAXPROCS(4) // Permitir até 4 threads para paralelismo
}

Andere Programmiersprachen bieten ebenfalls Tools für Parallelität und Parallelität, der Abstraktionsgrad und die Einfachheit variieren jedoch stark. In Java verfügen wir beispielsweise über die Concurrent API (java.util.concurrent) und Tools wie Thread, ExecutorService und ForkJoinPool, um Parallelität und Parallelität zu verwalten.

Der Entwickler muss jedoch den Thread-Pool manuell konfigurieren oder bestimmte Tools wie CompletableFuture verwenden, um asynchrone Vorgänge zu vereinfachen.

Java ermöglicht auch die parallele Ausführung auf Multicore-Maschinen mithilfe von Thread-Pools. Im Gegensatz dazu sind Threads in Java jedoch schwerer, da sie direkt Betriebssystem-Threads zugeordnet sind.

Laufzeit-X-Kernel

Betriebssystem-Threads werden vom Systemkernel verwaltet. Das bedeutet, dass das Erstellen, Zerstören, Kontextwechseln und Verwalten von Threads Aufgaben sind, die der Kernel ausführt, was zu zusätzlichem Overhead führt. Jeder Betriebssystem-Thread verbraucht eine beträchtliche Menge an Speicher (normalerweise etwa 1 MB in Java). Wenn das System zwischen Threads wechselt, muss es Prozessorzustände (Register, Stapel usw.) speichern und wiederherstellen, was ein teurer Prozess ist.

In Go ist es die Sprachlaufzeit, die diese Verwaltung übernimmt. Go erstellt nicht für jede Goroutine einen Betriebssystem-Thread. Stattdessen verwaltet die Go-Laufzeit mehrere Goroutinen auf einer viel kleineren Anzahl von Betriebssystem-Threads – technisch gesehen M:N-Scheduling (M Goroutinen auf N Threads). Dies ermöglicht
Tausende von Goroutinen mit der gleichen Anzahl von Threads, ohne das Betriebssystem zu überlasten.

Und das ist die „Anmut“ der Sprache, die sie zum Favoriten für die Verwaltung verteilter Hochleistungssysteme und Echtzeit-Datenverarbeitungsanwendungen macht.

Es ist jedoch wichtig zu betonen, dass jede moderne Sprache in der Lage ist, mit Parallelität und Parallelität zu arbeiten.

Der Unterschied liegt in der Leichtigkeit und den Verarbeitungskosten.

Auf diese Weise müssen wir nicht in einer FlaxFlu von Sprachen bleiben. Jede Sprache hat ihre Magie, ihre Stärken und Schwächen.

Um zu zeigen, wie jede Sprache diese Aufgaben ausführen kann, werde ich in Go und Java beispielhaft zeigen, wie dasselbe Programm codiert wird, jedes mit seinen eigenen Besonderheiten. Die Idee ist einfach: Simulieren Sie eine Aufgabe, die mit Parallelität und Parallelität ausgeführt wird, und drucken Sie die Ausführungszeit und Speichernutzung in beiden Fällen aus (die Zahlen variieren für jede Maschine).

Um den Vergleich „freier“ zu gestalten, habe ich chatgpt gebeten, die folgenden Codes zu generieren:

Golang

import (
    "runtime"
)

func main() {
    runtime.GOMAXPROCS(4) // Permitir até 4 threads para paralelismo
}

Ausführungszeit: 141,886206 ms
Verwendeter Speicher: 43909120 Bytes

Java

package main

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

func tarefa(id int) {
    // Simula algum processamento leve
    time.Sleep(10 * time.Millisecond)
}

func main() {
    // Configura a quantidade de tarefas
    numTarefas := 100000

    // Medindo o tempo de execução
    start := time.Now()

    var wg sync.WaitGroup
    wg.Add(numTarefas)

    // Calculando a quantidade de memória usada
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    initialMemory := m.Sys

    // Criando as goroutines para simular o trabalho
    for i := 0; i < numTarefas; i++ {
        go func(id int) {
            defer wg.Done()
            tarefa(id)
        }(i)
    }

    wg.Wait() // Espera todas as goroutines terminarem

    // Calculando o tempo total de execução e a memória usada
    elapsed := time.Since(start)
    runtime.ReadMemStats(&m)
    finalMemory := m.Sys

    // Printando os resultados
    fmt.Printf("Tempo de execução: %s\n", elapsed)
    fmt.Printf("Memória utilizada: %d bytes\n", finalMemory-initialMemory)
}

Ausführungszeit: 10238 ms
Verwendeter Speicher: 106732888 Bytes

Jedenfalls können wir eindeutig genau die gleiche Aufgabe in beiden Sprachen ausführen. Jeder nutzt seine Bibliotheken für die entsprechenden Zwecke. Es wird darauf hingewiesen, dass die Ausführung in Go 98,61 % schneller war und 58,86 % weniger Speicher verwendet wurden.

Aber es gibt keine bessere Sprache als eine andere.

Wir müssen lediglich die Vor- und Nachteile jeder einzelnen Sprache verstehen, wenn wir auswählen, welche Sprache uns bei der Lösung der Probleme in unseren Projekten helfen kann. Und jedes Projekt wird seinen Pool an besonderen und einzigartigen Problemen haben, die gelöst werden müssen.

Optimierung in Java

Es ist natürlich möglich, mithilfe von Strategien zu versuchen, die Leistung des oben bereitgestellten Codes in Java zu verbessern.

Ich habe chatgpt erneut gebeten, ein paar Tricks in den ursprünglichen Code zu integrieren:

import (
    "runtime"
)

func main() {
    runtime.GOMAXPROCS(4) // Permitir até 4 threads para paralelismo
}

Um den Speicherverbrauch zu reduzieren, verwenden wir einen ForkJoinPool mit einer größeren Anzahl von Threads (100), um eine hohe Parallelität besser bewältigen zu können. Dadurch wird der Standard-Thread-Pool ersetzt und sichergestellt, dass mehr Aufgaben gleichzeitig ausgeführt werden können. Wir rufen außerdem „Submit“ und „Join“ auf, um sicherzustellen, dass alle Aufgaben abgeschlossen sind, bevor das Programm beendet wird.

Mit diesen Änderungen wurde die Speicherzuweisung um 56,21 % reduziert:

Ausführungszeit: 11877 ms
Verwendeter Speicher: 46733064 Bytes

Die Optimierung dieses Codes ist eine interessante Herausforderung. Wir laden Sie ein, Java besser zu nutzen, was immer sehr gut möglich ist, da diese Sprache, wie wir wissen, unabhängig von jedem Detail wunderbar ist.

Das obige ist der detaillierte Inhalt vonKonkurrenz und Parallelität: Ist Golang in dieser Hinsicht besser als Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!