package com.jxz.threads;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

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

/**
 * @Author jiangxuzhao
 * @Description
 * @Date 2024/9/10
 */
@Slf4j
public class ThreadCreateTest {
    @Test
    @SneakyThrows
    public void test1() {
        // 匿名類重寫 Thread#run
        Thread thread1 = new Thread() {
            @Override
            public void run() {
                log.info("extend thread#run...");
            }
        };
        thread1.start();
        // 避免主線程直接結(jié)束
        Thread.sleep(1000);
    }

    @Test
    @SneakyThrows
    public void test2() {
        // Lambda 表達(dá)式定義實現(xiàn) Runnable target, Thread#run 方法最終調(diào)用 target#run
        Thread thread2 = new Thread(() -> {
            log.info("implement 自定義變量 target 的 Runnable#run...");
        });
        thread2.start();
        // 避免主線程直接結(jié)束
        Thread.sleep(1000);
    }

    @Test
    @SneakyThrows
    public void test3() {
        // Lambda 表達(dá)式定義實現(xiàn) callable#call，可以在主線程中通過 Future#get 阻塞獲取結(jié)果 result
        FutureTask<String> stringFutureTask = new FutureTask<>(() -> {
            log.info("implement Callable#call");
            return Thread.currentThread().getName();
        });
        Thread thread3 = new Thread(stringFutureTask);
        thread3.start();
        // 阻塞獲取結(jié)果，不用擔(dān)心主線程直接結(jié)束
        log.info("thread3 futureTask callable output = {}", stringFutureTask.get());
    }

    @Test
    @SneakyThrows
    public void test4() {
        // 線程池實現(xiàn)異步多線程
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        Future<String> stringFuture = executorService.submit(() -> {
            log.info("thread pool submit");
            return Thread.currentThread().getName();
        });
        // 阻塞獲取結(jié)果，不用擔(dān)心主線程直接結(jié)束
        log.info("thead submit output = {}", stringFuture.get());
    }
}

public
class Thread implements Runnable {
  	// 在 jdk 底層的 Thread.c 文件中定義了各種方法
    private static native void registerNatives();
  
  	// 確保 registerNatives 是 <clinit> 中第一件做的事
    static {
        registerNatives();
    }
}

// 當(dāng)前線程的名稱
private volatile String name;
private int            priority;
private Thread         threadQ;
private long           eetop;

/* Whether or not to single_step this thread. */
private boolean     single_step;

// 當(dāng)前線程是否在后臺運行
/* Whether or not the thread is a daemon thread. */
private boolean     daemon = false;

/* JVM state */
private boolean     stillborn = false;

// init 構(gòu)造方法中傳入的執(zhí)行任務(wù)，當(dāng)其不為空時，會執(zhí)行此任務(wù)
/* What will be run. */
private Runnable target;

// 當(dāng)前線程所在的線程組
/* The group of this thread */
private ThreadGroup group;

// 當(dāng)前線程的類加載器
/* The context ClassLoader for this thread */
private ClassLoader contextClassLoader;

/* The inherited AccessControlContext of this thread */
private AccessControlContext inheritedAccessControlContext;

// 被用來定義 "Thread-" + nextThreadNum() 的線程名，自增的序號在線程池打印日志中很常見
// 靜態(tài)變量 threadInitNumber 在 static synchronized 方法中自增，這個方法被調(diào)用時在 Thread.class 類上加 synchronized 鎖，保證單臺 JVM 虛擬機上都通過 Thread.class 并發(fā)創(chuàng)建線程 init 時，線程自增序號的并發(fā)安全
/* For autonumbering anonymous threads. */
private static int threadInitNumber;
private static synchronized int nextThreadNum() {
    return threadInitNumber++;
}

// 每個線程都維護(hù)一個 ThreadLocalMap，這個在保障線程安全的 ThreadLocal 中經(jīng)常出現(xiàn)
/* ThreadLocal values pertaining to this thread. This map is maintained
 * by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;

/*
 * InheritableThreadLocal values pertaining to this thread. This map is
 * maintained by the InheritableThreadLocal class.
 */
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

/*
 * The requested stack size for this thread, or 0 if the creator did
 * not specify a stack size.  It is up to the VM to do whatever it
 * likes with this number; some VMs will ignore it.
 */
private long stackSize;

/*
 * JVM-private state that persists after native thread termination.
 */
private long nativeParkEventPointer;

/*
 * Thread ID
 */
private long tid;

/* For generating thread ID */
private static long threadSeqNumber;

/* Java thread status for tools,
 * initialized to indicate thread 'not yet started'
 */

private volatile int threadStatus = 0;


private static synchronized long nextThreadID() {
    return ++threadSeqNumber;
}

/**
 * The argument supplied to the current call to
 * java.util.concurrent.locks.LockSupport.park.
 * Set by (private) java.util.concurrent.locks.LockSupport.setBlocker
 * Accessed using java.util.concurrent.locks.LockSupport.getBlocker
 */
volatile Object parkBlocker;

/* The object in which this thread is blocked in an interruptible I/O
 * operation, if any.  The blocker's interrupt method should be invoked
 * after setting this thread's interrupt status.
 */
private volatile Interruptible blocker;
private final Object blockerLock = new Object();

/* Set the blocker field; invoked via sun.misc.SharedSecrets from java.nio code
 */
void blockedOn(Interruptible b) {
    synchronized (blockerLock) {
        blocker = b;
    }
}

/**
 * The minimum priority that a thread can have.
 */
public final static int MIN_PRIORITY = 1;

/**
 * The default priority that is assigned to a thread.
 */
public final static int NORM_PRIORITY = 5;

/**
 * The maximum priority that a thread can have.
 */
public final static int MAX_PRIORITY = 10;

public Thread() {
    init(null, null, "Thread-" + nextThreadNum(), 0);
}

public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}


Thread(Runnable target, AccessControlContext acc) {
    init(null, target, "Thread-" + nextThreadNum(), 0, acc, false);
}

public Thread(ThreadGroup group, Runnable target) {
    init(group, target, "Thread-" + nextThreadNum(), 0);
}

public Thread(String name) {
    init(null, null, name, 0);
}

public Thread(ThreadGroup group, String name) {
    init(group, null, name, 0);
}

public Thread(Runnable target, String name) {
    init(null, target, name, 0);
}

public Thread(ThreadGroup group, Runnable target, String name) {
    init(group, target, name, 0);
}

public Thread(ThreadGroup group, Runnable target, String name,
              long stackSize) {
    init(group, target, name, stackSize);
}

private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize, AccessControlContext acc,
                  boolean inheritThreadLocals) {
    if (name == null) {
        throw new NullPointerException("name cannot be null");
    }

    this.name = name;

    Thread parent = currentThread();
    SecurityManager security = System.getSecurityManager();
    if (g == null) {
        /* Determine if it's an applet or not */

        /* If there is a security manager, ask the security manager
           what to do. */
        if (security != null) {
            g = security.getThreadGroup();
        }

        /* If the security doesn't have a strong opinion of the matter
           use the parent thread group. */
        if (g == null) {
            g = parent.getThreadGroup();
        }
    }

    /* checkAccess regardless of whether or not threadgroup is
       explicitly passed in. */
    g.checkAccess();

    /*
     * Do we have the required permissions?
     */
    if (security != null) {
        if (isCCLOverridden(getClass())) {
            security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
        }
    }

    g.addUnstarted();

    this.group = g;
    this.daemon = parent.isDaemon();
    this.priority = parent.getPriority();
    if (security == null || isCCLOverridden(parent.getClass()))
        this.contextClassLoader = parent.getContextClassLoader();
    else
        this.contextClassLoader = parent.contextClassLoader;
    this.inheritedAccessControlContext =
            acc != null ? acc : AccessController.getContext();
  
  	// 就是上面成員變量中的 target，在這里賦值
    this.target = target;
    setPriority(priority);
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals =
            ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    /* Stash the specified stack size in case the VM cares */
    this.stackSize = stackSize;

    /* Set thread ID */
    tid = nextThreadID();
}

public enum State {
    /**
     * Thread state for a thread which has not yet started.
     */
  	// 初始化狀態(tài)
    NEW,

    /**
     * Thread state for a runnable thread.  A thread in the runnable
     * state is executing in the Java virtual machine but it may
     * be waiting for other resources from the operating system
     * such as processor.
     */
  	// 可運行狀態(tài)，可運行狀態(tài)可以包括：運行中狀態(tài)和就緒狀態(tài)。
    RUNNABLE,

    /**
     * Thread state for a thread blocked waiting for a monitor lock.
     * A thread in the blocked state is waiting for a monitor lock
     * to enter a synchronized block/method or
     * reenter a synchronized block/method after calling
     * {@link Object#wait() Object.wait}.
     */
  	// 線程阻塞狀態(tài)
    BLOCKED,

    /**
     * Thread state for a waiting thread.
     * A thread is in the waiting state due to calling one of the
     * following methods:
     * <ul>
     *   <li>{@link Object#wait() Object.wait} with no timeout</li>
     *   <li>{@link #join() Thread.join} with no timeout</li>
     *   <li>{@link LockSupport#park() LockSupport.park}</li>
     * </ul>
     *
     * <p>A thread in the waiting state is waiting for another thread to
     * perform a particular action.
     *
     * For example, a thread that has called <tt>Object.wait()</tt>
     * on an object is waiting for another thread to call
     * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
     * that object. A thread that has called <tt>Thread.join()</tt>
     * is waiting for a specified thread to terminate.
     */
  	// 等待狀態(tài)
    WAITING,

    /**
     * Thread state for a waiting thread with a specified waiting time.
     * A thread is in the timed waiting state due to calling one of
     * the following methods with a specified positive waiting time:
     * <ul>
     *   <li>{@link #sleep Thread.sleep}</li>
     *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
     *   <li>{@link #join(long) Thread.join} with timeout</li>
     *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
     *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
     * </ul>
     */
  	// 超時等待狀態(tài)
    TIMED_WAITING,

    /**
     * Thread state for a terminated thread.
     * The thread has completed execution.
     */
  	// 線程終止?fàn)顟B(tài)
    TERMINATED;
}

public synchronized void start() {
    /**
     * This method is not invoked for the main method thread or "system"
     * group threads created/set up by the VM. Any new functionality added
     * to this method in the future may have to also be added to the VM.
     *
     * A zero status value corresponds to state "NEW".
     */
  	// 1. 判斷線程狀態(tài)是否為 NEW 初始化，否則直接拋出異常
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    /* Notify the group that this thread is about to be started
     * so that it can be added to the group's list of threads
     * and the group's unstarted count can be decremented. */
  	// 2. 加入線程組
    group.add(this);
	
  	// 線程是否已經(jīng)啟動標(biāo)志位，啟動后設(shè)置為 true
    boolean started = false;
    try {
      	// 3. 調(diào)用本地方法啟動線程
        start0();
      	// 啟動后設(shè)置標(biāo)志位為 true
        started = true;
    } finally {
        try {
          	// 4. 如果啟動失敗，把線程從線程組中移除
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}

// JVM 真正啟動線程的本地方法
private native void start0();

// 自定義重寫 Thread#run() 或者傳入 Runnable，最終都會調(diào)用該線程的 run() 方法邏輯
// 如果傳入了 Runnable 就會走進(jìn)這個方法運行 target.run()，有點裝飾器模式的感覺
@Override
public void run() {
    if (target != null) {
        target.run();
    }
}

// 本地方法，真正讓線程休眠的方法
public static native void sleep(long millis) throws InterruptedException;

/**
 * Causes the currently executing thread to sleep (temporarily cease
 * execution) for the specified number of milliseconds plus the specified
 * number of nanoseconds, subject to the precision and accuracy of system
 * timers and schedulers. The thread does not lose ownership of any
 * monitors.
 *
 * @param  millis
 *         the length of time to sleep in milliseconds
 *
 * @param  nanos
 *         {@code 0-999999} additional nanoseconds to sleep
 *
 * @throws  IllegalArgumentException
 *          if the value of {@code millis} is negative, or the value of
 *          {@code nanos} is not in the range {@code 0-999999}
 *
 * @throws  InterruptedException
 *          if any thread has interrupted the current thread. The
 *          <i>interrupted status</i> of the current thread is
 *          cleared when this exception is thrown.
 */
public static void sleep(long millis, int nanos)
throws InterruptedException {
    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
                            "nanosecond timeout value out of range");
    }

    if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
        millis++;
    }
		
  	// 調(diào)用本地方法
    sleep(millis);
}

// 調(diào)用方法，比方說 Main 線程調(diào)用 ThreadA.join()，就是 Main 線程會等待 ThreadA 執(zhí)行完成
public final void join() throws InterruptedException {
    join(0);
}

public final synchronized void join(long millis)
throws InterruptedException {
    long base = System.currentTimeMillis();
    long now = 0;

    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (millis == 0) {
      	// 該分支是無限期等待 ThreadA 結(jié)束，其實內(nèi)部最后是在 ThreadA 結(jié)束時被 notify 
        while (isAlive()) {
            wait(0);
        }
    } else {
      	// 該分支時等待有限的時間，如果 ThreadA 在 delay 時間以后還未結(jié)束，等待線程也返回了
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}

public void interrupt() {
    if (this != Thread.currentThread())
        checkAccess();

    synchronized (blockerLock) {
        Interruptible b = blocker;
        if (b != null) {
            interrupt0();           // Just to set the interrupt flag
            b.interrupt(this);
            return;
        }
    }
  	// 調(diào)用本地方法中斷線程
    interrupt0();
}