Java多线程Thread及其原理详解

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();
        // 避免主线程直接结束
        thread.sleep(1000);
    }

    @test
    @sneakythrows
    public void test2() {
        // lambda 表达式定义实现 runnable target, thread#run 方法最终调用 target#run
        thread thread2 = new thread(() -> {
            log.info("implement 自定义变量 target 的 runnable#run...");
        });
        thread2.start();
        // 避免主线程直接结束
        thread.sleep(1000);
    }

    @test
    @sneakythrows
    public void test3() {
        // lambda 表达式定义实现 callable#call，可以在主线程中通过 future#get 阻塞获取结果 result
        futuretask<string> stringfuturetask = new futuretask<>(() -> {
            log.info("implement callable#call");
            return thread.currentthread().getname();
        });
        thread thread3 = new thread(stringfuturetask);
        thread3.start();
        // 阻塞获取结果，不用担心主线程直接结束
        log.info("thread3 futuretask callable output = {}", stringfuturetask.get());
    }

    @test
    @sneakythrows
    public void test4() {
        // 线程池实现异步多线程
        executorservice executorservice = executors.newfixedthreadpool(1);
        future<string> stringfuture = executorservice.submit(() -> {
            log.info("thread pool submit");
            return thread.currentthread().getname();
        });
        // 阻塞获取结果，不用担心主线程直接结束
        log.info("thead submit output = {}", stringfuture.get());
    }
}

public
class thread implements runnable {
  	// 在 jdk 底层的 thread.c 文件中定义了各种方法
    private static native void registernatives();
  
  	// 确保 registernatives 是 <clinit> 中第一件做的事
    static {
        registernatives();
    }
}

// 当前线程的名称
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;

// 当前线程是否在后台运行
/* whether or not the thread is a daemon thread. */
private boolean     daemon = false;

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

// init 构造方法中传入的执行任务，当其不为空时，会执行此任务
/* what will be run. */
private runnable target;

// 当前线程所在的线程组
/* the group of this thread */
private threadgroup group;

// 当前线程的类加载器
/* the context classloader for this thread */
private classloader contextclassloader;

/* the inherited accesscontrolcontext of this thread */
private accesscontrolcontext inheritedaccesscontrolcontext;

// 被用来定义 "thread-" + nextthreadnum() 的线程名，自增的序号在线程池打印日志中很常见
// 静态变量 threadinitnumber 在 static synchronized 方法中自增，这个方法被调用时在 thread.class 类上加 synchronized 锁，保证单台 jvm 虚拟机上都通过 thread.class 并发创建线程 init 时，线程自增序号的并发安全
/* for autonumbering anonymous threads. */
private static int threadinitnumber;
private static synchronized int nextthreadnum() {
    return threadinitnumber++;
}

// 每个线程都维护一个 threadlocalmap，这个在保障线程安全的 threadlocal 中经常出现
/* 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.
     */
  	// 初始化状态
    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.
     */
  	// 可运行状态，可运行状态可以包括：运行中状态和就绪状态。
    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}.
     */
  	// 线程阻塞状态
    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.
     */
  	// 等待状态
    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>
     */
  	// 超时等待状态
    timed_waiting,

    /**
     * thread state for a terminated thread.
     * the thread has completed execution.
     */
  	// 线程终止状态
    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. 判断线程状态是否为 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);
	
  	// 线程是否已经启动标志位，启动后设置为 true
    boolean started = false;
    try {
      	// 3. 调用本地方法启动线程
        start0();
      	// 启动后设置标志位为 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，最终都会调用该线程的 run() 方法逻辑
// 如果传入了 runnable 就会走进这个方法运行 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++;
    }
		
  	// 调用本地方法
    sleep(millis);
}

// 调用方法，比方说 main 线程调用 threada.join()，就是 main 线程会等待 threada 执行完成
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 结束，其实内部最后是在 threada 结束时被 notify 
        while (isalive()) {
            wait(0);
        }
    } else {
      	// 该分支时等待有限的时间，如果 threada 在 delay 时间以后还未结束，等待线程也返回了
        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;
        }
    }
  	// 调用本地方法中断线程
    interrupt0();
}