1/**
2 * JAVA 19 - RECORD PATTERNS (JEP 405) - 1. PREVIEW
3 * =================================================
4 *
5 * Bu dosya, Record Patterns'in Java 19'daki ILK preview halini gosterir.
6 * (Daha gelismis / kalici ornekler: 13-Java-20 ve 14-Java-21 klasorleri.)
7 *
8 * NEDIR?
9 *   Bir record'u eslestirirken (instanceof / switch), bilesenlerini DOGRUDAN
10 *   degiskenlere "yikma" (destructuring) imkani. Tur eslesmesi ve alan
11 *   cikarimi tek adimda olur.
12 *
13 * NEDEN GELDI?
14 *   Pattern matching (Java 16) ile turu ogrenip bir degiskene baglayabiliyorduk,
15 *   ancak alanlara yine tek tek erismek gerekiyordu. Record patterns bu adimi
16 *   ortadan kaldirir.
17 *
18 * --- DERLEME / CALISTIRMA (Java 19'da PREVIEW) ---
19 *   javac --release 19 --enable-preview RecordPatternsPreview.java
20 *   java  --enable-preview RecordPatternsPreview
21 *
22 *   NOT: Java 21'de bu ozellik KALICI oldu; orada --enable-preview gerekmez.
23 */
24public class RecordPatternsPreview {
25
26    // Basit record'lar
27    record Nokta(int x, int y) {}
28    record Cizgi(Nokta baslangic, Nokta bitis) {}
29
30    public static void main(String[] args) {
31        System.out.println("=== JAVA 19: RECORD PATTERNS (1. PREVIEW) ===\n");
32
33        Object n = new Nokta(3, 4);
34        Object c = new Cizgi(new Nokta(0, 0), new Nokta(10, 5));
35
36        eskiYontem(n);
37        yeniYontem(n);
38        icIceYikim(c);
39    }
40
41    /** ESKI: once instanceof ile tur, sonra alanlara erisim metoduyla. */
42    private static void eskiYontem(Object nesne) {
43        System.out.println("--- ESKI yontem (alanlara tek tek erisim) ---");
44        if (nesne instanceof Nokta nk) {
45            int x = nk.x();
46            int y = nk.y();
47            System.out.println("  Nokta: x=" + x + ", y=" + y);
48        }
49        System.out.println();
50    }
51
52    /** YENI: record pattern ile yikim. Tur + alan cikarimi tek satirda. */
53    private static void yeniYontem(Object nesne) {
54        System.out.println("--- YENI yontem (record pattern / yikim) ---");
55        // x ve y dogrudan burada tanimlanir
56        if (nesne instanceof Nokta(int x, int y)) {
57            System.out.println("  Nokta: x=" + x + ", y=" + y);
58        }
59        System.out.println();
60    }
61
62    /**
63     * IC ICE YIKIM (nested destructuring): Record patterns en cok burada parlar.
64     * Cizgi'nin icindeki iki Nokta'nin alanlarini tek desende cikariyoruz.
65     */
66    private static void icIceYikim(Object nesne) {
67        System.out.println("--- Ic ice yikim (nested record pattern) ---");
68        if (nesne instanceof Cizgi(Nokta(int x1, int y1), Nokta(int x2, int y2))) {
69            int dx = x2 - x1;
70            int dy = y2 - y1;
71            double uzunluk = Math.sqrt(dx * dx + dy * dy);
72            System.out.printf("  Cizgi (%d,%d)->(%d,%d), uzunluk=%.2f%n",
73                    x1, y1, x2, y2, uzunluk);
74        }
75        System.out.println();
76    }
77}

1import java.time.Duration;
2import java.util.concurrent.Executors;
3import java.util.concurrent.atomic.AtomicInteger;
4
5/**
6 * JAVA 19 - VIRTUAL THREADS (JEP 425) - 1. PREVIEW (Project Loom)
7 * ===============================================================
8 *
9 * Bu dosya, Virtual Threads'in Java 19'daki ILK preview halini gosterir.
10 * (Kalici ve cok daha derin anlatim icin: 14-Java-21/VirtualThreadsKalici.java)
11 *
12 * --- KAVRAMLAR ---
13 *  PLATFORM THREAD (klasik):
14 *    - Bir OS thread'inin dogrudan sarmalayicisidir.
15 *    - ~1 MB stack tuketir, OS kaynagidir, sayisi sinirlidir (~binlerce).
16 *  VIRTUAL THREAD (yeni):
17 *    - JVM tarafindan yonetilir, cok hafiftir (~birkac yuz byte baslangic).
18 *    - Az sayida "carrier" (tasiyici) OS thread uzerinde coklanir.
19 *    - Bloklayici I/O'da JVM thread'i tasiyicidan SOKER (unmount), tasiyiciyi
20 *      baska bir virtual thread'e verir. Boylece OS thread bosta beklemez.
21 *    - MILYONLARCA virtual thread olusturulabilir.
22 *
23 * --- DERLEME / CALISTIRMA (Java 19'da PREVIEW oldugu icin gerekli) ---
24 *   javac --release 19 --enable-preview VirtualThreadsPreview.java
25 *   java  --enable-preview VirtualThreadsPreview
26 *
27 *   NOT: Java 21'de bu ozellik KALICI oldu; orada --enable-preview gerekmez.
28 */
29public class VirtualThreadsPreview {
30
31    public static void main(String[] args) throws InterruptedException {
32        System.out.println("=== JAVA 19: VIRTUAL THREADS (1. PREVIEW) ===\n");
33
34        ornek1_tekVirtualThread();
35        ornek2_cokSayidaVirtualThread();
36        ornek3_executorIleVirtualThread();
37
38        System.out.println("\n=== Ozet ===");
39        System.out.println("""
40                * Virtual thread = cok hafif, JVM yonetimli thread.
41                * Bloklayici (senkron) kod yaz; reaktif olceklenebilirligi al.
42                * Java 19'da PREVIEW; Java 21'de KALICI oldu.
43                """);
44    }
45
46    /** En basit kullanim: tek bir virtual thread baslat. */
47    private static void ornek1_tekVirtualThread() throws InterruptedException {
48        System.out.println("--- Ornek 1: Tek virtual thread ---");
49
50        // Thread.ofVirtual() -> virtual thread fabrikasi
51        Thread vt = Thread.ofVirtual().name("ilk-vt").start(() ->
52                System.out.println("  Merhaba virtual thread'ten! isVirtual="
53                        + Thread.currentThread().isVirtual()));
54
55        vt.join(); // bitmesini bekle
56        System.out.println();
57    }
58
59    /**
60     * Cok sayida virtual thread: 10.000 thread. Platform thread'le bu sayi
61     * cogu sistemde OutOfMemoryError verir; virtual thread'le sorunsuzdur.
62     */
63    private static void ornek2_cokSayidaVirtualThread() throws InterruptedException {
64        System.out.println("--- Ornek 2: 10.000 virtual thread ---");
65        int adet = 10_000;
66        AtomicInteger sayac = new AtomicInteger();
67
68        Thread[] threadler = new Thread[adet];
69        for (int i = 0; i < adet; i++) {
70            threadler[i] = Thread.ofVirtual().start(() -> {
71                try {
72                    // Bloklayici bir islemi taklit et (orn. ag/DB cagrisi)
73                    Thread.sleep(Duration.ofMillis(100));
74                    sayac.incrementAndGet();
75                } catch (InterruptedException ignored) { }
76            });
77        }
78        for (Thread t : threadler) t.join();
79
80        System.out.println("  " + sayac.get() + " virtual thread tamamlandi.");
81        System.out.println("  (Platform thread ile 10.000 adet cogu makinede patlardi.)\n");
82    }
83
84    /**
85     * En yaygin uretim deseni: her gorev icin yeni bir virtual thread acan
86     * bir executor. Web sunucularda "her istek icin bir virtual thread"
87     * modelinin temeli budur.
88     */
89    private static void ornek3_executorIleVirtualThread() throws InterruptedException {
90        System.out.println("--- Ornek 3: newVirtualThreadPerTaskExecutor ---");
91
92        // try-with-resources: executor kapaninca tum gorevlerin bitmesini bekler
93        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
94            for (int i = 1; i <= 5; i++) {
95                int gorevNo = i;
96                executor.submit(() -> {
97                    System.out.println("  Gorev " + gorevNo + " calisiyor ("
98                            + Thread.currentThread() + ")");
99                    return gorevNo;
100                });
101            }
102        } // executor.close() -> tum gorevler bitene kadar bloklar
103        System.out.println();
104    }
105}