Thread类介绍

Thread

public class Thread implements Runnable {
    /** 这里只看一些 常见的参数 */
    /** 线程名 */
    private volatile char name[];
    /** 优先级 */
    private int priority;
    /** 是否为守护线程 */
    private boolean daemon;
    /** 线程要执行的目标任务 */
    private Runnable target;
    /** 所属线程组 */
    private ThreadGroup group;
    /** 类加载器 */
    private ClassLoader contextClassLoader;
    /**
     * ThreadLocal 能为线程设置线程私有变量 就是通过下面这个threadLocals变量完成的，
     * ThreadLocal的get/set方法就是通过操作 各个线程的 threadLocals 变量实现的。
     * 1、线程A持有一个 ThreadLocalMap 变量；
     * 2、线程A调用一个类的 ThreadLocal变量 tlA 的 get/set方法；
     * 3、tlA（ThreadLocal）的 get/set方法 获取当前线程A，调用 线程A 的 ThreadLocalMap变量 的get/put方法；
     * 4、其它线程 调用 tlA（ThreadLocal）的 get/set方法 同理。
     */
    ThreadLocal.ThreadLocalMap threadLocals;
    ThreadLocal.ThreadLocalMap inheritableThreadLocals;
    /** 线程栈的大小 */
    private long stackSize;
    /**
     * Thread类定义了6个线程状态：New、Runnable、Blocked、Waiting、TimedWaiting、Terminated(终止)
     * 实际上还会把 Runnable 再细分为 就绪(未抢到时间片) 和 运行中(抢到时间片)
     */
    private volatile int threadStatus;
    /** 最小优先级 */
    public static final int MIN_PRIORITY = 1;
    /** 中等优先级 */
    public static final int NORM_PRIORITY = 5;
    /** 最大优先级 */
    public static final int MAX_PRIORITY = 10;

    /**
     * 内部枚举类，用来描述线程状态，状态值有：
     * NEW：          新建，还未调用start()方法；
     * RUNNABLE：     运行，在java多线程模型中，就绪和运行都是运行状态；
     * BLOCKED：      阻塞；
     * WAITING：      等待，需要其他的线程来唤醒；
     * TIMED_WAITING：超时等待，可以在指定的时间内自动醒来，如 sleep()方法；
     * TERMINATED：   终止，线程执行完毕。
     */
    public static final class State extends Enum {

        public static final State NEW;
        public static final State RUNNABLE;
        public static final State BLOCKED;
        public static final State WAITING;
        public static final State TIMED_WAITING;
        public static final State TERMINATED;
        private static final State VALUES[];

        static {
            NEW = new State("NEW", 0);
            RUNNABLE = new State("RUNNABLE", 1);
            BLOCKED = new State("BLOCKED", 2);
            WAITING = new State("WAITING", 3);
            TIMED_WAITING = new State("TIMED_WAITING", 4);
            TERMINATED = new State("TERMINATED", 5);
            VALUES = (new State[] { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED });
        }

        private State(String s, int i) {
            super(s, i);
        }
    }

    /**
     * 一系列 构造方法 ------------------------------------------------------
     * 可以看出来，其中都调用了init()方法，这也是一个约定俗成的规矩， 即，如果要在 new 时进行一些初始化操作，
     * 那么请将初始化操作单独写在 init()方法中，然后在构造函数中调用该 init()方法
     */
    public Thread() {
        daemon = false;
        stillborn = false;
        threadLocals = null;
        inheritableThreadLocals = null;
        threadStatus = 0;
        blockerLock = new Object();
        init(null, null, (new StringBuilder()).append("Thread-").append(nextThreadNum()).toString(), 0L);
    }

    public Thread(Runnable runnable) {
        daemon = false;
        stillborn = false;
        threadLocals = null;
        inheritableThreadLocals = null;
        threadStatus = 0;
        blockerLock = new Object();
        init(null, runnable, (new StringBuilder()).append("Thread-").append(nextThreadNum()).toString(), 0L);
    }

    Thread(Runnable runnable, AccessControlContext accesscontrolcontext) {
        daemon = false;
        stillborn = false;
        threadLocals = null;
        inheritableThreadLocals = null;
        threadStatus = 0;
        blockerLock = new Object();
        init(null, runnable, (new StringBuilder()).append("Thread-").append(nextThreadNum()).toString(), 0L,
                accesscontrolcontext);
    }

    public Thread(ThreadGroup threadgroup, Runnable runnable) {
        daemon = false;
        stillborn = false;
        threadLocals = null;
        inheritableThreadLocals = null;
        threadStatus = 0;
        blockerLock = new Object();
        init(threadgroup, runnable, (new StringBuilder()).append("Thread-").append(nextThreadNum()).toString(), 0L);
    }

    public Thread(String s) {
        daemon = false;
        stillborn = false;
        threadLocals = null;
        inheritableThreadLocals = null;
        threadStatus = 0;
        blockerLock = new Object();
        init(null, null, s, 0L);
    }

    public Thread(ThreadGroup threadgroup, String s) {
        daemon = false;
        stillborn = false;
        threadLocals = null;
        inheritableThreadLocals = null;
        threadStatus = 0;
        blockerLock = new Object();
        init(threadgroup, null, s, 0L);
    }

    public Thread(Runnable runnable, String s) {
        daemon = false;
        stillborn = false;
        threadLocals = null;
        inheritableThreadLocals = null;
        threadStatus = 0;
        blockerLock = new Object();
        init(null, runnable, s, 0L);
    }

    public Thread(ThreadGroup threadgroup, Runnable runnable, String s) {
        daemon = false;
        stillborn = false;
        threadLocals = null;
        inheritableThreadLocals = null;
        threadStatus = 0;
        blockerLock = new Object();
        init(threadgroup, runnable, s, 0L);
    }

    public Thread(ThreadGroup threadgroup, Runnable runnable, String s, long l) {
        daemon = false;
        stillborn = false;
        threadLocals = null;
        inheritableThreadLocals = null;
        threadStatus = 0;
        blockerLock = new Object();
        init(threadgroup, runnable, s, l);
    }

    private void init(ThreadGroup threadgroup, Runnable runnable, String s, long l) {
        init(threadgroup, runnable, s, l, null);
    }

    /**
     * 初始化线程
     */
    private void init(ThreadGroup threadgroup, Runnable runnable, String name, long l,
            AccessControlContext accesscontrolcontext) {

        // 参数校验，线程name不能为null
        if (name == null)
            throw new NullPointerException("name cannot be null");
        this.name = name.toCharArray();
        // 当前线程就是该线程的父线程
        Thread parent = currentThread();
        SecurityManager securitymanager = System.getSecurityManager();
        if (threadgroup == null) {
            if (securitymanager != null)
                threadgroup = securitymanager.getThreadGroup();
            if (threadgroup == null)
                threadgroup = parent.getThreadGroup();
        }
        threadgroup.checkAccess();
        if (securitymanager != null && isCCLOverridden(getClass()))
            securitymanager.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
        threadgroup.addUnstarted();
        // 守护线程、优先级等设置为父线程的对应属性
        group = threadgroup;
        daemon = parent.isDaemon();
        priority = parent.getPriority();
        if (securitymanager == null || isCCLOverridden(parent.getClass()))
            contextClassLoader = parent.getContextClassLoader();
        else
            contextClassLoader = parent.contextClassLoader;
        inheritedAccessControlContext = accesscontrolcontext == null ? AccessController.getContext()
                : accesscontrolcontext;
        target = runnable;
        setPriority(priority);
        if (parent.inheritableThreadLocals != null)
            // 创建线程共享变量副本
            inheritableThreadLocals = ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        stackSize = l;
        // 分配线程id
        tid = nextThreadID();
    }

    public synchronized void start() {
        //假若当前线程初始化还未做好，不能start，0->NEW状态
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        //通知group该线程即将启动，group的未启动线程数量减1
        group.add(this);

        boolean started = false;
        try {
            // 调用native的start0()方法 启动线程，启动后执行run()方法
            start0();
            started = true;
        } finally {
            try {
                //启动不成功，group设置当前线程启动失败
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {

            }
        }
    }

    private native void start0();

    public void run() {
        if (target != null)
            target.run();
    }

    /**
     * 请求终止线程。interrupt不会真正停止一个线程，它仅仅是给这个线程发了一个信号，
     * 告诉它要结束了，具体要中断还是继续运行，将由被通知的线程自己处理
     */
    public void interrupt() {
        if (this != Thread.currentThread())
            checkAccess();
        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {
                interrupt0();
                b.interrupt(this);
                return;
            }
        }
        interrupt0();
    }

    private native void interrupt0();

    /**
     * 线程main 调用了线程A的join方法，则 线程main 会被阻塞，直到线程A执行完毕
     */
    public final void join() throws InterruptedException {
        join(0);
    }

    /**
     * `实际上是利用 wait/notify机制 来实现的`
     */
    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");
        }
        // millis 为 0，所以走这个分支
        if (millis == 0) {
            // 当前线程是否还在运行，还在运行 则main线程 进入等待状态，直到 A线程运行完毕，将其唤醒
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

    /**
     * 线程睡眠指定的时间，释放CPU资源，但不释放锁
     */
    public static native void sleep(long millis) throws InterruptedException;

    /**
     * 线程是否还在运行
     */
    public final native boolean isAlive();
}