Java Academy · Pelajaran

Membuat Virtual Thread

Thread.ofVirtual dan executor.

Membuat Virtual Thread adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Java Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Java Academy mencakup 4 pelajaran total.

Cara Membuat Utas Virtual

Java menyediakan beberapa titik masuk untuk membuat utas virtual. Dua yang paling penting adalah pembuat Thread.ofVirtual() dan factory Executors.newVirtualThreadPerTaskExecutor().

Pelajaran ini membahas masing-masing cara tersebut.

Pembuat: start

Thread.ofVirtual() mengembalikan sebuah pembuat. Pemanggilan .start(runnable) membuat dan langsung memulai utas tersebut.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = Thread.ofVirtual().start(() ->
            System.out.println("Started directly"));
        t.join();
    }
}

Pembuat: unstarted

Gunakan .unstarted(runnable) jika Anda ingin mengonfigurasi utas terlebih dahulu dan memulainya nanti.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = Thread.ofVirtual().unstarted(() ->
            System.out.println("Started later"));
        System.out.println("Before start, alive? " + t.isAlive());
        t.start();
        t.join();
    }
}

Factory yang Dapat Digunakan Kembali

Pembuat dapat menghasilkan ThreadFactory melalui .factory(). Setiap pemanggilan newThread menghasilkan utas virtual baru.

import java.util.concurrent.ThreadFactory;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        ThreadFactory factory = Thread.ofVirtual().name("job-", 0).factory();
        Thread a = factory.newThread(() ->
            System.out.println(Thread.currentThread().getName()));
        Thread b = factory.newThread(() ->
            System.out.println(Thread.currentThread().getName()));
        a.start(); b.start();
        a.join(); b.join();
    }
}

Metode Praktis

Thread.startVirtualThread(runnable) adalah bentuk singkat untuk membuat dan memulai utas virtual tanpa nama dalam satu pemanggilan.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = Thread.startVirtualThread(() ->
            System.out.println("One-liner virtual thread"));
        t.join();
    }
}

Pendekatan Eksekutor

Untuk kode yang berorientasi pada tugas, pilih Executors.newVirtualThreadPerTaskExecutor(). Eksekutor ini membuat utas virtual baru untuk setiap tugas yang dikirimkan.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
            exec.submit(() -> System.out.println("task one"));
            exec.submit(() -> System.out.println("task two"));
        }
        System.out.println("All tasks submitted and completed");
    }
}

Mengapa Menggunakan Blok Sumber Daya

Sejak Java 19, ExecutorService mengimplementasikan AutoCloseable. Menutupnya dalam blok coba-dengan-sumber daya akan menunggu semua tugas yang dikirimkan selesai.

Dengan begitu, penghentian berlangsung rapi dan terstruktur tanpa pemanggilan manual shutdown dan awaitTermination.

Mengirimkan Banyak Tugas

Eksekutor per tugas dapat menangani jumlah tugas yang sangat besar dengan mudah. Setiap tugas mendapatkan utas virtualnya sendiri.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args) {
        AtomicInteger sum = new AtomicInteger();
        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 1; i <= 1000; i++) {
                final int n = i;
                exec.submit(() -> sum.addAndGet(n));
            }
        }
        System.out.println("Sum 1..1000 = " + sum.get());
    }
}

Mengumpulkan Hasil dengan Nilai Tertunda

submit mengembalikan Future, sehingga Anda dapat mengumpulkan nilai hasil seperti halnya pada eksekutor mana pun.

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws Exception {
        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
            Future<Integer> f = exec.submit(() -> 6 * 7);
            System.out.println("Result: " + f.get());
        }
    }
}

Pembuat dibandingkan dengan Eksekutor

Pilih berdasarkan tujuan:

Pembuat / startVirtualThread untuk utas sekali pakai atau penamaan khusus
newVirtualThreadPerTaskExecutor untuk mengirimkan kumpulan tugas dan mengumpulkan hasilnya

Keduanya membuat satu utas virtual untuk setiap unit pekerjaan, persis seperti yang Anda perlukan.

Jangan Menyimpan Eksekutor Virtual dalam Tembolok

Jangan menggunakan kembali satu eksekutor utas virtual seolah-olah eksekutor tersebut merupakan kumpulan pekerja tetap. Eksekutornya sendiri boleh digunakan kembali, tetapi ingat bahwa setiap tugas membuat utas yang benar-benar baru.

Intinya, utas tidak dikumpulkan; yang tersedia hanyalah pengiriman tugas yang praktis.

Uji Singkat

Pilih cara terbaik untuk menjalankan sejumlah besar tugas, masing-masing pada utas virtualnya sendiri.

Rangkuman

Sekarang Anda mengetahui cara membuat utas virtual:

Thread.ofVirtual().start(...) dan .unstarted(...)
Satu baris Thread.startVirtualThread(...)
.factory() untuk ThreadFactory yang dapat digunakan kembali
Executors.newVirtualThreadPerTaskExecutor() dengan blok coba-dengan-sumber daya

Selanjutnya: memilih antara utas platform dan utas virtual.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Membuat Virtual Thread” gratis?

Ya — teks lengkap “Membuat Virtual Thread” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Java Academy, upgrade ke CoddyKit PRO. Kursus Java Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Membuat Virtual Thread”?

Thread.ofVirtual dan executor. Kamu berlatih Java Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Java Academy?

Tidak diperlukan pengalaman sebelumnya. Java Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Membuat Virtual Thread” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Java Academy