Thread类源码解析

作者: 指尖上的榴莲 | 来源:发表于2019-09-20 21:39 被阅读0次

一.概述

Java中所有多线程的实现，均通过封装Thread类实现，所以通过源码深入研究Thread类，对深入理解java多线程很有必要，本文Thread类源码均基于JDK 1.8。

二.线程的状态

通过Thread类的内部枚举类State可以知道，线程有以下六个状态。

public enum State {
        /**
         * 线程刚创建，尚未启动（还未调用 start() 方法）的状态
         */
        NEW,

        /**
         * 可运行线程的线程状态。调用了 start() 方法，此时线程已经准备好被执行，处于就绪队列中。
         * 处于此状态的线程是正在JVM中运行的，但可能在等待操作系统中的其他资源，如CPU时间片。
         */
        RUNNABLE,

        /**
         * 阻塞等待监视器锁的状态。处于此状态的线程正在阻塞等待监视器锁，以进入一个同步块/方法，
         * 或者在执行完wait()方法后重入同步块/方法。
         */
        BLOCKED,

        /**
         * 等待状态。执行完Object.wait无超时参数操作，或者 Thread.join无超时参数操作，
         * 或者 LockSupport.park操作后，线程进入等待状态。
         * 一般在等待状态的线程在等待其它线程执行特殊操作，例如：
         * 等待其它线程调用Object.notify()唤醒或者Object.notifyAll()唤醒所有。
         */
        WAITING,

        /**
         * 计时等待状态。Thread.sleep、Object.wait带超时时间、Thread.join带超时时间、
         * LockSupport.parkNanos、LockSupport.parkUntil这些操作会使线程进入计时等待状态。
         */
        TIMED_WAITING,

        /**
         * 终止状态，线程执行完毕。
         */
        TERMINATED;
    }

通过下面的线程状态转换图，可以对线程状态的转换有更深刻的认识：

线程的状态转换图

创建状态（New）
当用new操作符创建一个新的线程对象时，该线程处于创建状态，尚未启动（还未调用 start() 方法）。
处于创建状态的线程只是一个空的线程对象，系统不为它分配资源。
可运行状态（Runnable）
处于创建状态的线程调用start()方法，系统将为线程分配必需的资源（JVM会为其创建程序计数器和方法调用栈），则此线程进入可运行状态。
线程处于可运行状态只说明它具备了运行条件，但可运行状态并不一定是正在运行的状态。一个线程能否由可运行状态变为运行状态，取决于系统的调度。
运行状态（Running）
处于可运行状态的线程已经具备了运行条件，但还没有分配到CPU，处于线程就绪队列（尽管是采用队列形式，事实上，把它称为可运行池而不是可运行队列。因为cpu的调度不一定是按照先进先出的顺序来调度的），等待系统为其分配CPU。
一旦获得CPU，线程就进入运行状态并自动调用自己的run方法。
不可运行状态（Waiting/Blocked/Timed Waiting）
处于运行状态的线程最为复杂，它可以变为可运行状态和不可运行状态。例如，对运行状态的线程调用yield()方法，它就会让出cpu资源，再次变为可运行状态。
当发生下列事件时，处于运行状态的线程会转入到不可运行状态：
(1)当线程调用wait()方法来等待另一个线程的通知，或者等待另一个调用join()方法的线程执行结束时，线程就会进入等待状态。
(2)当一个线程试图获取一个内部的对象锁，而该锁被其他线程持有，则该线程进入阻塞状态。
(3)当线程调用sleep()方法时，传递一个超时参数，则会使线程进入计时等待状态。
返回可运行状态：
(1)通知消息到来或另一个调用join()方法的线程执行结束时,线程会进入可运行状态。
(2)当其他线程释放对象锁，并且线程调度器允许本线程持有该锁时，该线程将变为可运行状态。
(3) 处于计时等待状态的线程在指定的时间过去后，会变为可运行状态。
死亡状态
线程正常结束或因异常退出run()方法，线程进入死亡状态。
线程一旦进入死亡状态，将不再具有运行的资格，所以也不可能再转到其他状态。线程一旦死亡，就不能复生。如果在一个死去的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。
线程会通过以下三种方式进入死亡状态：
(1)run()方法执行完成，线程正常结束。
(2)线程抛出一个未捕获的Exception或Error。
(3)直接调用stop()方法强行终止线程（这个方法不推荐使用，因为stop和suspend、resume一样，容易导致死锁）。

三.基本属性

Thread类中的基本属性如下所示。

 /* Make sure registerNatives is the first thing <clinit> does. */
 // 类加载的时候，调用静态的registerNatives()方法， 这个方法是本地方法
    private static native void registerNatives();
    static {
        registerNatives();
    }
    
    //线程名字
    private volatile String name;
    //线程优先级
    private int            priority;
    private Thread         threadQ;
    private long           eetop;

    //是否是单步执行
    private boolean     single_step;

    //是否是守护线程
    private boolean     daemon = false;

    //JVM状态
    private boolean     stillborn = false;

    //从构造方法传过来的Runnable，实际要执行的线程任务
    private Runnable target;

    //当前线程所在的线程组
    private ThreadGroup group;

    //当前线程的上下文类加载器
    private ClassLoader contextClassLoader;

    //当前线程继承的访问控制上下文
    private AccessControlContext inheritedAccessControlContext;

    //线程的默认编号，用于生成线程的默认名字
    private static int threadInitNumber;
    private static synchronized int nextThreadNum() {
        return threadInitNumber++;
    }

    //当前线程维护的ThreadLocal值，ThreadLocalMap会被ThreadLocal类维护
    ThreadLocal.ThreadLocalMap threadLocals = null; 

    //当前线程维护的从父线程那里继承的ThreadLocal值
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

    //给这个线程设置的栈的大小,默认为0
    private long stackSize;

    private long nativeParkEventPointer;

    // 线程id
    private long tid;

    //用于生成线程id
    private static long threadSeqNumber;

    //标识线程状态，默认是线程未启动
    private volatile int threadStatus = 0;

    //得到下个线程id
    private static synchronized long nextThreadID() {
        return ++threadSeqNumber;
    }

    volatile Object parkBlocker;

    private volatile Interruptible blocker;

    private final Object blockerLock = new Object();

    //设置blocker字段
    void blockedOn(Interruptible b) {
        synchronized (blockerLock) {
            blocker = b;
        }
    }

    //线程执行的最低优先级
    public final static int MIN_PRIORITY = 1;

   //线程执行的默认优先级
    public final static int NORM_PRIORITY = 5;

    //线程执行的最高的优先级
    public final static int MAX_PRIORITY = 10;

四.构造方法

要创建一个Thread类的实例自然要通过构造函数，Thread类的public构造函数有8个之多，但是他们本质上都调用了同一个init函数:

public Thread() {
    init(null, null, "Thread-" + nextThreadNum(), 0);
}
public Thread(String name) {
    init(null, null, name, 0);
}
public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}
public Thread(Runnable target, String name) {
    init(null, target, name, 0);
}
public Thread(ThreadGroup group, Runnable target) {
    init(group, target, "Thread-" + nextThreadNum(), 0);
}
public Thread(ThreadGroup group, String name) {
    init(group, null, 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);
}

可见，这八个public类型的构造函数只不过是给init的方法的四个参数分别赋不同的值, 这四个参数分别是:

ThreadGroup g（线程所在线程组）
Runnable target （Runnable对象）
String name （线程的名字）
long stackSize （为线程分配的栈的大小，若为0则表示忽略这个参数）

而init方法又调用了另一个init方法，设置了AccessControlContext，以及inheritThreadLocals参数:

    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize) {
        init(g, target, name, stackSize, null, true);
    }

    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) {
            //如果没有传入线程组的话， 首先使用SecurityManager中的ThreadGroup
            if (security != null) {
                g = security.getThreadGroup();
            }
            //如果从SecurityManager中获取不到ThreadGroup， 那么就从父线程中获取线程组
            if (g == null) {
                g = parent.getThreadGroup();
            }
        }

        g.checkAccess();

        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);
        //设置栈深度
        this.stackSize = stackSize;

        //设置线程ID
        tid = nextThreadID();
    }

五.native方法

    //获得当前正在执行的线程的引用
    public static native Thread currentThread();

   //使当前线程从运行状态（Running）变为可运行状态（Runnable）
    public static native void yield();

    //强制当前正在执行的线程休眠（暂停执行），休眠结束后，线程返回到可运行状态
    public static native void sleep(long millis) throws InterruptedException;

    //启动线程，为线程分配对应的资源
    private native void start0();

    //查看当前线程是否被中断
    private native boolean isInterrupted(boolean ClearInterrupted);

    //查看当前线程是否存活
    public final native boolean isAlive();

    //获取当前线程栈帧的数量
    public native int countStackFrames();

     //当且仅当当前线程在指定的对象上持有监视器锁时，才返回 true
    public static native boolean holdsLock(Object obj);

    private native static StackTraceElement[][] dumpThreads(Thread[] threads);
    private native static Thread[] getThreads();

   //设置线程优先级
    private native void setPriority0(int newPriority);
    //停止线程
    private native void stop0(Object o);
    //挂起线程
    private native void suspend0();
    //将一个挂起线程复活继续执行
    private native void resume0();
    //设置该线程的中断状态
    private native void interrupt0();
    private native void setNativeName(String name);

六.主要方法

1.start()方法

    public synchronized void start() {
        //线程只能被启动一次，不能被重复启动，如果线程已启动则抛出异常
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        //向线程组中添加此线程
        group.add(this);

        boolean started = false;
        try {
            //调用native方法
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    // 如果线程启动失败，从线程组里面移除该线程
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

synchronized 关键字说明start方法是同步的，并且是启动这个线程进行执行，JVM将会调用这个线程的run方法。这样产生的结果是，两个线程在并发执行，其中一个是调用start()方法的线程，另一个是当前thread对象代表的线程，它会执行run方法。

2.sleep()方法

    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);
    }

sleep()方法的作是使当前线程休眠一定的时间，让其他线程有机会继续执行，但是这个期间是不释放持有的锁的，调用sleep()方法需要捕捉异常。

3.join()方法

join()方法的实现原理，可以看我之前写的一篇文章：Thread类中join方法的实现原理

4.interrupt()方法

    public void interrupt() {
        if (this != Thread.currentThread())
            //检查权限
            checkAccess();

        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {
                //只是设置了中断标志位
                interrupt0();         
                b.interrupt(this);
                return;
            }
        }
        interrupt0();
    }

其实调用interrupt()方法并不是真的中断线程，只是将Thread中的interrupt标志设置为true，用户需自行检测这一变量，停止线程。
其实Thread类中与线程中断有关的，有三个方法，比较容易混淆，在这里解释一下。

    public void interrupt()                //将线程设置为中断状态
    public boolean isInterrupted()         //判断是否被中断
    public static boolean interrupted()    //判断是否被中断，被清除当前中断状态

一般来说，阻塞函数：如Thread.sleep、Thread.join、Object.wait等在检查到线程的中断状态的时候，会抛出InteruptedExeption, 也就是说，它可以用来中断一个正处于阻塞状态的线程，同时会清除线程的中断状态。

5.exit( )方法

    private void exit() {
        if (group != null) {
            group.threadTerminated(this);
            group = null;
        }
        target = null;
        threadLocals = null;
        inheritableThreadLocals = null;
        inheritedAccessControlContext = null;
        blocker = null;
        uncaughtExceptionHandler = null;
    }

exit( )是由系统调用的，用于线程在真正的退出前进行一些清理的操作。

参考：
Thread类源码分析
 Java常用类源码——Thread源码解析
 Thread类源码解读(1)——如何创建和启动线程

Thread类源码解析

一.概述

二.线程的状态

三.基本属性

四.构造方法

五.native方法

六.主要方法

1.start()方法

2.sleep()方法

3.join()方法

4.interrupt()方法

5.exit( )方法

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读