Thread 생성과 start

public final class RunMethodCreatesNoThreadBug {
    public static void main(String[] args) {
        Thread first = new NamedWork("alpha");
        Thread second = new NamedWork("beta");
        first.run();
        second.run();
        System.out.println("wrong-result=both calls used " + Thread.currentThread().getName());
    }

    private static final class NamedWork extends Thread {
        NamedWork(String name) {
            super(name);
        }

        @Override
        public void run() {
            System.out.println(
                    "requested=" + getName() + ", actual=" + Thread.currentThread().getName());
        }
    }
}

public final class JavaEnvironmentProbe {
    public static void main(String[] args) {
        Runtime runtime = Runtime.getRuntime();
        System.out.println("feature=" + Runtime.version().feature());
        System.out.println("vm=" + System.getProperty("java.vm.name"));
        System.out.println("processors=" + runtime.availableProcessors());
        System.out.println("main-thread=" + Thread.currentThread().getName());
    }
}

public final class RangeSumThread extends Thread {
    private final int startInclusive;
    private final int endInclusive;
    private long result;

    public RangeSumThread(String name, int startInclusive, int endInclusive) {
        super(name);
        this.startInclusive = startInclusive;
        this.endInclusive = endInclusive;
    }

    @Override
    public void run() {
        long sum = 0;
        for (int n = startInclusive; n <= endInclusive; n++) {
            sum += n;
        }
        result = sum;
        System.out.println(getName() + " stack finished " + startInclusive + ".." + endInclusive);
    }

    public long result() {
        return result;
    }

    public static void main(String[] args) throws InterruptedException {
        RangeSumThread left = new RangeSumThread("left-sum", 1, 500);
        RangeSumThread right = new RangeSumThread("right-sum", 501, 1000);
        left.start();
        right.start();
        left.join();
        right.join();
        System.out.println("total=" + (left.result() + right.result()));
    }
}

public final class StartTwiceFailure {
    public static void main(String[] args) throws InterruptedException {
        Thread oneShot = new Thread(() -> System.out.println("one run"), "one-shot");
        oneShot.start();
        oneShot.join();
        System.out.println("state-before-restart=" + oneShot.getState());
        oneShot.start();
    }
}

import java.util.List;

public final class NamedImportWorkers {
    public static void main(String[] args) throws InterruptedException {
        List<String> files = List.of("java.md", "thread.md", "memory.md");
        Thread[] workers = new Thread[files.size()];
        for (int i = 0; i < workers.length; i++) {
            String file = files.get(i);
            workers[i] = new Thread(() -> importFile(file), "import-" + (i + 1));
            workers[i].setUncaughtExceptionHandler(
                    (thread, error) ->
                            System.err.println(
                                    thread.getName() + ":" + error.getClass().getSimpleName()));
            workers[i].start();
        }
        for (Thread worker : workers) {
            worker.join();
        }
        System.out.println("imported=" + workers.length);
    }

    private static void importFile(String file) {
        System.out.println(Thread.currentThread().getName() + " -> " + file);
    }
}

public final class RunThenStartTraceSolution {
    private static final class CountingThread extends Thread {
        private int runs;

        CountingThread() { super("counted-worker"); }

        @Override
        public void run() {
            runs++;
            System.out.println("actual=" + Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        CountingThread worker = new CountingThread();
        System.out.println("before=" + worker.getState());
        worker.run();
        System.out.println("after-direct=" + worker.getState());
        worker.start();
        worker.join();
        System.out.println("runs=" + worker.runs + ", state=" + worker.getState());
        try {
            worker.start();
        } catch (IllegalThreadStateException expected) {
            System.out.println("restart=" + expected.getClass().getSimpleName());
        }
    }
}