LockSupport의 park·unpark

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.LockSupport;

public final class DoubleUnparkPermitBug {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch mayPark = new CountDownLatch(1), firstReturned = new CountDownLatch(1);
        Thread worker =
                new Thread(
                        () -> {
                            await(mayPark);
                            LockSupport.park();
                            firstReturned.countDown();
                            LockSupport.park();
                        },
                        "double-park");
        worker.start();
        LockSupport.unpark(worker);
        LockSupport.unpark(worker);
        mayPark.countDown();
        firstReturned.await();
        worker.join(20);
        System.out.println("wrong-second-permit=" + !worker.isAlive());
        worker.interrupt();
        worker.join();
    }

    private static void await(CountDownLatch latch) {
        try {
            latch.await();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.LockSupport;

public final class OneBitPermitOrder {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch enter = new CountDownLatch(1);
        Thread worker =
                new Thread(
                        () -> {
                            await(enter);
                            LockSupport.park("first-permit");
                            System.out.println("park-returned");
                        },
                        "permit-worker");
        worker.start();
        LockSupport.unpark(worker);
        enter.countDown();
        worker.join();
        System.out.println("state=" + worker.getState());
    }

    private static void await(CountDownLatch latch) {
        try {
            latch.await();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

import java.util.concurrent.locks.LockSupport;

public final class ParkedConditionGate {
    private volatile boolean open;
    private volatile Thread waiter;

    public void awaitOpen() {
        waiter = Thread.currentThread();
        while (!open) {
            LockSupport.park(this);
            if (Thread.interrupted()) throw new IllegalStateException("gate wait interrupted");
        }
    }

    public void open() {
        open = true;
        Thread target = waiter;
        if (target != null) LockSupport.unpark(target);
    }

    public static void main(String[] args) throws InterruptedException {
        ParkedConditionGate gate = new ParkedConditionGate();
        Thread worker =
                new Thread(
                        () -> {
                            gate.awaitOpen();
                            System.out.println("gate-open");
                        },
                        "condition-waiter");
        worker.start();
        while (worker.getState() != Thread.State.WAITING) {
            Thread.onSpinWait();
        }
        gate.open();
        worker.join();
    }
}

import java.util.ArrayDeque;
import java.util.Queue;
import java.util.concurrent.locks.LockSupport;

public final class ParkedJobDispatcher {
    private final Queue<String> jobs = new ArrayDeque<>();
    private final Thread worker = new Thread(this::consume, "park-dispatcher");
    private boolean closed;

    public void start() {
        worker.start();
    }

    public void submit(String job) {
        synchronized (jobs) {
            if (closed) throw new IllegalStateException("closed");
            jobs.add(job);
        }
        LockSupport.unpark(worker);
    }

    public void close() throws InterruptedException {
        synchronized (jobs) {
            closed = true;
        }
        LockSupport.unpark(worker);
        worker.join();
    }

    private void consume() {
        for (; ; ) {
            String job;
            synchronized (jobs) {
                job = jobs.poll();
                if (job == null && closed) return;
            }
            if (job == null) {
                LockSupport.park(this);
                continue;
            }
            System.out.println("handled=" + job);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ParkedJobDispatcher d = new ParkedJobDispatcher();
        d.start();
        d.submit("index");
        d.submit("publish");
        d.close();
        System.out.println("dispatcher-closed");
    }
}