Persaingan dan keselarian: adakah Golang berprestasi lebih baik daripada Java dalam hal ini?

Salah satu kelebihan utama Golang (atau Go), bahasa yang dicipta oleh Google, ialah pengurusan pertandingan, iaitu keupayaan untuk menjalankan berbilang tugas pada masa yang sama.

Setiap bahasa moden mempunyai alat untuk menangani konkurensi. Apa yang membezakan Go ialah masa jalan mengabstraksi sebahagian besar butiran tentang benang dan keselarian untuk kami, yang menjadikan pemprosesan ini lebih mudah. Ia adalah masa jalan, bukan kernel sistem pengendalian, yang mentakrifkan cara goroutine diperuntukkan kepada urutan sistem pengendalian dan cara utas berinteraksi dengan teras CPU yang tersedia.

Pemaju boleh menggunakan concurrency (pelaksanaan berjalin) dan selari (pelaksanaan serentak) pada masa yang sama dalam Go Dan dia juga boleh melakukannya secara eksplisit dengan menentukan sifat GOMAXPROCS yang merupakan had urutan serentak dalam program. Jadi Go boleh memetakan goroutine pada berbilang teras untuk mendapatkan keselarian sebenar, dan mesin yang mempunyai seni bina ini dalam pemprosesan. Secara lalai, walau bagaimanapun, masa jalan sudah melakukan abstraksi ini untuk kita.

import (
    "runtime"
)

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

Bahasa pengaturcaraan lain juga menawarkan alat untuk konkurensi dan keselarian, tetapi tahap abstraksi dan kesederhanaan sangat berbeza. Di Java, sebagai contoh, kami mempunyai API Serentak (java.util.concurrent) dan alatan seperti Thread, ExecutorService dan ForkJoinPool untuk mengurus concurrency dan parallelism.

Walau bagaimanapun, pembangun perlu mengkonfigurasi kumpulan benang secara manual atau menggunakan alatan tertentu seperti CompletableFuture untuk memudahkan operasi tak segerak.

Java juga membenarkan pelaksanaan selari pada mesin berbilang teras menggunakan kumpulan benang. Sebaliknya, walau bagaimanapun, benang dalam Java lebih berat kerana ia dipetakan terus ke urutan sistem pengendalian.

Runtime X Kernel

Benang sistem pengendalian diuruskan oleh kernel sistem. Ini bermakna mencipta, memusnahkan, menukar konteks dan mengurus benang ialah tugas yang dilakukan oleh kernel, memperkenalkan overhed tambahan. Setiap urutan sistem pengendalian menggunakan sejumlah besar memori (biasanya sekitar 1 MB dalam Java). Apabila sistem bertukar antara benang, ia perlu menyimpan dan memulihkan keadaan pemproses (pendaftaran, tindanan, dll.), yang merupakan proses yang mahal.

Dalam Go, masa jalan bahasa yang melakukan pengurusan ini. Go tidak mencipta urutan sistem pengendalian untuk setiap goroutine. Sebaliknya, masa jalanan Go mengurus berbilang goroutin pada bilangan urutan sistem pengendalian yang jauh lebih kecil - secara teknikal dipanggil penjadualan M:N (M goroutines pada benang N). Ini membolehkan
beribu-ribu goroutine dengan bilangan utas yang sama tanpa membebankan sistem pengendalian.

Dan ini adalah "rahmat" bahasa, menjadikannya kegemaran untuk mengurus sistem pengedaran berprestasi tinggi dan aplikasi pemprosesan data masa nyata.

Walau bagaimanapun, adalah penting untuk menekankan bahawa mana-mana bahasa moden mampu berfungsi dengan serentak dan selari.

Perbezaannya adalah pada tahap ringan dan kos pemprosesan.

Dengan cara ini, kita tidak perlu kekal dalam FlaxFlu bahasa. Setiap bahasa mempunyai keajaiban, kekuatan dan kelemahannya.

Hanya untuk menunjukkan cara mana-mana bahasa boleh melaksanakan tugasan ini, saya akan contohkan dalam Go dan Java bagaimana program yang sama dikodkan, masing-masing mempunyai keistimewaan tersendiri. Ideanya mudah: simulasikan tugasan yang dilakukan dengan serentak dan selari dan cetak masa pelaksanaan dan penggunaan memori dalam kedua-dua kes (nombor berbeza untuk setiap mesin).

Untuk menjadikan perbandingan lebih "dikecualikan", saya meminta chatgpt untuk menjana kod, seperti di bawah:

Golang

import (
    "runtime"
)

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

Masa pelaksanaan: 141.886206ms
Memori yang digunakan: 43909120 bait

Jawa

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)
}

Masa pelaksanaan: 10238 ms
Memori yang digunakan: 106732888 bait

Bagaimanapun, kami boleh melaksanakan tugas yang sama dengan jelas dalam kedua-dua bahasa. Masing-masing menggunakan perpustakaan mereka untuk tujuan yang sesuai. Adalah diperhatikan bahawa dalam Go pelaksanaan adalah 98.61% lebih pantas dan 58.86% kurang memori digunakan.

Tetapi tidak ada bahasa yang lebih baik daripada bahasa lain.

Apa yang kami perlukan ialah memahami kebaikan dan keburukan setiap satu apabila memilih bahasa yang boleh membantu kami menyelesaikan masalah yang kami hadapi dalam projek kami. Dan setiap projek akan mempunyai kumpulan masalah tertentu dan unik yang perlu diselesaikan.

Pengoptimuman di Jawa

Sudah tentu, anda boleh menggunakan strategi untuk cuba meningkatkan prestasi kod yang disediakan di atas dalam Java.

Saya meminta chatgpt sekali lagi untuk memasukkan beberapa helah ke dalam kod awal:

import (
    "runtime"
)

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

Untuk mengurangkan penggunaan ingatan, kami menggunakan ForkJoinPool, dengan bilangan utas yang lebih besar (100) untuk menangani kesesuaian yang tinggi dengan lebih baik. Ini menggantikan kumpulan benang lalai, memastikan lebih banyak tugas boleh dijalankan serentak. Kami juga memanggil hantar dan sertai untuk memastikan semua tugasan selesai sebelum menamatkan program.

Dengan perubahan ini, peruntukan memori telah dikurangkan sebanyak 56.21%:

Masa pelaksanaan: 11877 ms
Memori yang digunakan: 46733064 bait

Mengoptimumkan kod ini ialah satu cabaran yang menarik. Kami menjemput anda untuk melakukan yang lebih baik menggunakan Java, yang sentiasa sangat mungkin, kerana bahasa ini, kami tahu, hebat tanpa mengira sebarang butiran.

Atas ialah kandungan terperinci Persaingan dan keselarian: adakah Golang berprestasi lebih baik daripada Java dalam hal ini?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!