JDK19中的虚拟线程

import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ForkJoinPool;
import java.util.stream.IntStream;

/**
 * A thread that is scheduled by the Java virtual machine rather than the operating system.
 * @author Green.Gee
 * @date 2023/3/15 10:17
 * @email green.gee.lu@gmail.com
 */
public class VirtualThreadExample {

    public static void main(String[] args) throws InterruptedException {

        // platform thread
        var pthread =
                Thread.ofPlatform()
                .unstarted(() -> System.err.println(Thread.currentThread()));

        pthread.start();
        pthread.join();

        // virtual thread create
        // Base-On ForkJoinPool framework
        var virtual_thread =
                Thread.ofVirtual()
                .unstarted(() -> System.err.println(Thread.currentThread()));
        virtual_thread.start();
        virtual_thread.join();
        System.err.println("Class = " + virtual_thread.getClass());

        //ForkJoinPool
        var task = ForkJoinPool.commonPool()
                .submit(() -> System.err.println(Thread.currentThread()));
        task.join();

    }

    // show you something
    static void virtualThreadExample() throws InterruptedException{
        var threads = IntStream.range(0, 10) // thread nums
                .mapToObj(
                        index -> Thread.ofVirtual().unstarted(() -> {
                            if (index == 0) {
                                System.err.println(Thread.currentThread());
                            }
                            try {
                                Thread.sleep(10);
                            }catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                            if (index == 0) {
                                System.err.println(Thread.currentThread());
                            }
                        })
                )
                .toList();
        threads.forEach(Thread::start);
        for (Thread thread : threads) {
            thread.join();
        }
    }

    // virtual thread performance
    // synchronized
    //      fixed platform thread
    // java.util.concurrent.Lock
    //      jumps another platform thread
    static void virtualThreadPerformance(int maxVirtualThread) throws InterruptedException {
        var poolNames = ConcurrentHashMap.newKeySet();
        var pThreadNames = ConcurrentHashMap.newKeySet();

        var threads = IntStream.range(0, maxVirtualThread)
                .mapToObj(i -> Thread.ofVirtual()
                        .unstarted(() -> {
                            poolNames.add(Thread.currentThread().getName());
                        }))
                .toList();

        Instant begin = Instant.now();
        threads.forEach(Thread::start);
        for (Thread thread : threads) {
            thread.join();
        }
        Instant end = Instant.now();
        System.err.println("Time = " + Duration.between(begin, end).toMillis() + "ms");

    }
}