Projek Loom memperkenalkan benang maya ringan ke Java, memudahkan pembangunan aplikasi serentak yang tinggi. 1. Benang maya adalah ringan, benang yang diuruskan oleh JVM yang membolehkan kesesuaian besar-besaran tanpa overhead benang platform yang disokong OS. 2. 3. Thread maya dijalankan pada benang pembawa (benang platform), dan JVM secara automatik menukarnya semasa menyekat operasi untuk memaksimumkan penggunaan sumber. 4. Konvensyen berstruktur menyediakan hierarki tugas yang jelas dengan pembatalan automatik dan penyebaran kesilapan, meningkatkan debug dan pemerhatian. 5. Sehingga Java 21, benang maya adalah siap pengeluaran dan boleh digunakan melalui pelaksana. 6. Amalan terbaik termasuk menggunakan benang maya untuk tugas-tugas I/O yang terikat, mengelakkan pengumpulan, dan mengendalikan kerja intensif CPU. 7. Manfaat dunia nyata termasuk keseragaman pelayan web yang lebih mudah, penggunaan JDBC yang cekap, dan mengurangkan kerumitan dalam microservices. 8. Benang maya tidak boleh digunakan untuk tugas-tugas CPU yang terikat, aplikasi rendah, atau dalam persekitaran dengan alat penyahpepijatan yang sudah lapuk. Hasilnya ialah pemaju kini boleh menulis kod mudah, boleh dibaca, segerak yang skala seperti kod async kompleks, menjadikan benang maya menjadi penukar permainan untuk aplikasi Java sisi pelayan.

Thread Platform Java - lebih dikenali sebagai Project Loom - adalah evolusi utama dalam platform Java yang bertujuan untuk menjadikannya lebih mudah untuk menulis, menyelenggara, dan skala aplikasi serentak. Selepas bertahun -tahun pembangunan di bawah payung OpenJDK, Loom bersedia untuk membentuk semula bagaimana pemaju berfikir tentang kesesuaian di Jawa. Panduan ini memecahkan apa yang Projek Loom, mengapa ia penting, dan bagaimana anda boleh mula menggunakannya dengan berkesan.

Apa itu Loom Project?

Projek Loom adalah projek OpenJDK yang memperkenalkan benang maya ringan ke platform Java. Matlamatnya adalah untuk memudahkan pembangunan aplikasi serentak tinggi dengan secara drastik mengurangkan usaha yang diperlukan untuk menggunakan benang dengan cekap.

Aplikasi Java tradisional bergantung pada benang platform (juga dipanggil benang OS), yang diuruskan oleh JVM tetapi akhirnya disokong oleh benang sistem operasi. Ini mahal dari segi memori dan penjadualan overhead. Akibatnya, aplikasi yang perlu mengendalikan beribu -ribu atau berjuta -juta tugas serentak (seperti pelayan web atau microservices) sering menggunakan model pengaturcaraan asynchronous yang kompleks (misalnya, siap sedia, aliran reaktif).

Loom mengubah ini dengan memperkenalkan benang maya , iaitu:

• Ringan : Beribu -ribu atau berjuta -juta boleh dibuat tanpa sumber sistem yang meletihkan.
• Diuruskan oleh JVM : Mereka tidak terikat 1: 1 hingga benang OS.
• Drop-in serasi : mereka melaksanakan java.lang.Thread , jadi kod sedia ada berfungsi tidak berubah.
• Menyekat mesra : Tidak seperti model async, anda boleh menggunakan polos synchronized , Thread.sleep() , atau menyekat I/O tanpa penalti prestasi.

Pendek kata: Benang maya menjadikan skala kod mudah, seperti kod asynchronous yang kompleks .

Mengapa benang maya penting

Selama bertahun-tahun, industri telah menolak ke arah pengaturcaraan yang tidak menyekat, reaktif untuk mengendalikan kesesuaian pada skala. Rangka kerja seperti aliran reaktif , reaktor projek , dan vert.x mendapat populariti kerana benang platform tidak dapat skala dengan cekap.

Tetapi kod async datang dengan kos:

• Lebih sukar untuk dibaca dan debug.
• Pengendalian ralat rumit.
• Jejak timbunan menjadi cetek dan tidak membantu.
• Alat debugging tradisional berjuang.

Thread maya menawarkan penyelesaian terbaik dunia : berskala tinggi dengan kod yang mudah dan penting .

Contoh: Tradisional vs Loom

Sebelum Loom (threadpool siap sedia):

 ExecutOrservice Executor = executors.NewFixedThreadPool (10);
Intstream.range (0, 1000)
    .Foreach (i -> executor.submit (() -> {
        Thread.sleep (1000);
        System.out.println ("tugas" i "selesai");
        kembali null;
    }));

Hanya 10 tugas yang dijalankan serentak. Selebihnya tunggu - penggunaan yang lemah.

Dengan tenun:

 cuba (var executor = executors.newVirtualThreadPerTasKexecutor ()) {
    Intstream.range (0, 1000)
        .Foreach (i -> executor.submit (() -> {
            Thread.sleep (1000);
            System.out.println ("tugas" i "selesai");
            kembali null;
        }));
}
// ditutup secara automatik

Sekarang, semua 1,000 tugas berjalan serentak , masing -masing dalam benang maya sendiri. Benang OS yang mendasari (benang pembawa) digunakan dengan cekap - mungkin hanya beberapa dozen.

Ini besar-besaran untuk Java sisi pelayan.

Konsep utama dalam Loom Projek

1. Benang maya

• Benang ringan yang dijadualkan oleh JVM.
• Dicipta dalam jumlah besar (berfikir 100k).
• Setiap berjalan pada benang pembawa (benang platform biasa).
• Apabila blok benang maya (I/O, tidur, dan lain -lain), JVM menjadualkan satu lagi pada pembawa yang sama - tiada tempat letak kereta benang.

2. Thread Carrier

• Benang platform asas yang melaksanakan benang maya.
• Diuruskan oleh forkjoinpool secara lalai.
• Bilangan pembawa ≈ bilangan teras CPU (boleh dikonfigurasikan).
• JVM multiplexes benang maya ke pembawa seperti OS dilakukan dengan benang pada CPU.

3. Konvensyen berstruktur (pratonton)

Loom memperkenalkan API baru untuk kesesuaian berstruktur - paradigma yang memastikan tugas -tugas kanak -kanak dilengkapkan dengan betul dan diuruskan dalam tugas ibu bapa.

 cuba (skop var = baru StructuredTasksCope.ShutDownOnFailure ()) {
    var user = scope.fork (() -> fetchUser ());
    perintah var = scope.fork (() -> fetchorders ());

    scope.join (); // Tunggu kedua -duanya
    scope.throwiffailed (); // Menyebarkan kegagalan

    kembali hasil baru (user.get (), orders.get ());
}

Faedah:

• Hierarki tugas yang jelas.
• Pembatalan dan pembersihan automatik.
• Debugging dan pemerhatian yang lebih mudah.

Ini amat berguna dalam microservices dan pemprosesan permintaan.

Cara menggunakan benang maya hari ini

Sehingga Java 21 , benang maya adalah siap pengeluaran dan tersedia tanpa bendera.

1. Buat benang maya

Pilihan A: Executors (disyorkan)

 cuba (var executor = executors.newVirtualThreadPerTasKexecutor ()) {
    Intstream.range (0, 10_000) .foreach (i ->
        executor.submit (() -> {
            Thread.sleep (duration.ofseconds (1));
            System.out.println ("Selesai:" i);
            kembali null;
        })
    );
} // executor.shutdown () dipanggil secara automatik

Pilihan B: Penciptaan Manual (Tidak Biasa)

 Thread.StartVirtualThread (() -> {
    System.out.println ("Hello from Virtual Thread!");
    Thread.sleep (1000);
});

2. Gunakan dengan API yang ada

Kod yang paling menyekat berfungsi sebagai-adalah :

• Thread.sleep()
• JDBC (walaupun tidak async)
• Object.wait() / synchronized
• Menyekat I/O (misalnya, InputStream.read() )

Tidak perlu menulis semula asas kod anda.

Amalan terbaik dan perangkap

? Lakukan:

• Gunakan benang maya untuk model permintaan-per-thread (contohnya, pelayan web).
• Gunakan try-with-resources dengan newVirtualThreadPerTaskExecutor() .
• Lebih suka berstruktur berstruktur untuk orkestra tugas yang kompleks.
• Gunakan benang maya dengan menyekat I/O - itulah tempat yang manis mereka.

? Jangan:

• Kolam renang maya - mereka murah untuk mencipta; Menyatukan mengalahkan tujuannya.
• Gunakannya untuk kerja intensif CPU -melekat pada kolam renang platform (contohnya, ForkJoinPool ) untuk itu.
• Anggapkan mereka lebih cepat - mereka tidak lebih cepat setiap tugas, tetapi membenarkan throughput yang lebih tinggi kerana skalabiliti yang lebih baik.
• Campurkan benang maya dengan penyalahgunaan benang-tempatan-mereka boleh berhijrah antara pembawa, jadi nilai ThreadLocal boleh hilang kecuali menggunakan ThreadLocal.withInitial() dengan teliti.

Impak dunia nyata

Pelayan web

Rangka kerja seperti Spring Boot , Tomcat , Jetty , dan Netty sudah bereksperimen dengan atau menyokong benang maya.

Di Spring Boot 6 (Spring 6, Java 17), anda boleh mengaktifkan benang maya:

 pelayan:
  Threads:
    Maya:
      Diaktifkan: Benar

Hasil? Satu pelayan mengendalikan puluhan ribu permintaan serentak dengan kod mudah dan mudah dibaca.

Pangkalan data

Malah JDBC tradisional (menyekat) menjadi berdaya maju di bawah beban, kerana setiap pertanyaan berjalan dalam benang maya yang berasingan tanpa mengikat benang OS.

Microservices

Mengurangkan kerumitan dalam rantai async. Tidak ada lagi thenCompose , flatMap , atau subscribe() neraka.

Apabila tidak menggunakan benang maya

• Tugas terikat CPU : Gunakan ForkJoinPool atau kolam thread platform bersaiz tetap.
• Aplikasi Concurrency Rendah : Tiada manfaat jika anda hanya mempunyai beberapa benang.
• Legacy Thread-Local Heavy Code : Mungkin memerlukan refactoring.
• Alat Debugging Tidak Dikemaskini : Sesetengah Profiler atau Alat APM Lag dalam Sokongan Thread Maya (Meningkatkan Cepat).

Pemikiran terakhir

Projek Loom tidak hanya menambah ciri baru - ia mentakrifkan cara lalai untuk menulis kod Java serentak .

Anda tidak perlu memilih antara:

• Kesederhanaan (kod segerak) vs skalabiliti (async).
• Kebolehbacaan vs prestasi.

Dengan benang maya, anda boleh menulis kod mudah, menyekat, thread-per-request dan masih berskala untuk kesesuaian besar-besaran.

Ia bukan pengganti untuk pengaturcaraan async sepenuhnya-corak reaktif masih mempunyai tempat mereka-tetapi untuk kebanyakan aplikasi sisi pelayan, Loom adalah penukar permainan .

Bermula

1. Gunakan Java 21 atau lebih baru (versi LTS disyorkan).
2. Mulakan Kecil: Gantikan Executors.newCachedThreadPool() dengan newVirtualThreadPerTaskExecutor() .
3. Ujian di bawah beban - Lihat bagaimana throughput bertambah baik.
4. Terokai kesesuaian berstruktur untuk aliran kerja yang kompleks.

Masa depan Java Concurrency ada di sini - dan ia kelihatan seperti masa lalu, tetapi diperkuat dengan 100x.

Pada asasnya, jika anda menulis Java sisi pelayan, mula menggunakan benang maya sekarang .

Atas ialah kandungan terperinci Panduan Definitif ke Java Platform Threads (Project Loom). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!