乐趣区

浅析-Thread

jiezi

零 前期准备

0 FBI WARNING

文章异常啰嗦且绕弯。

1 版本

JDK 版本 : OpenJDK 12.0.1

IDE : idea 2019.2

2 Thread 简介

Thread 对象是 java 中线程的封装对象，用于控制线程的一切属性，也是 java 中最常用到的基础对象之一。

一 正文

1 Thread 类和成员变量

1.1 Thread 和 Runnable

在工程实践中 Thread 经常与 Runnable 一同使用，用于运行多线程程序。而本质上 Thread 也实现了 Runnnable：

// Thread.class
public class Thread implements Runnable {

    // 忽略其它成员变量和方法，暂时先只关注 Runnable 相关的方法
    // ...
    
    // 在创建 Thread 对象的时候可以传入的 Runnable 对象
    // 如果不传入则 run() 方法无效
    private Runnable target;

    // 执行 target 对象
    // 由此可见 Thread 本身其实是一个静态代理的典例
    @Override
    public void run() {if (target != null) {target.run();
        }
    }
}

1.2 成员变量

// 线程名称
private volatile String name;

// 线程优先级，数字越大优先级越高
private int priority;
// 最小优先级
public static final int MIN_PRIORITY = 1;
// 默认优先级
public static final int NORM_PRIORITY = 5;
// 最高优先级
public static final int MAX_PRIORITY = 10;

// 是否是守护线程，默认为 否
private boolean daemon = false;

/* Fields reserved for exclusive use by the JVM */
private boolean stillborn = false;
private long eetop;

// Runnable
private Runnable target;

// 该线程对象属于哪个线程组
private ThreadGroup group;

// 类加载器
private ClassLoader contextClassLoader;

private AccessControlContext inheritedAccessControlContext;

private static int threadInitNumber;

// 线程绑定的 ThreadLocal
ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

// 栈大小
private final long stackSize;

private long nativeParkEventPointer;

// 线程 id
private final long tid;

private static long threadSeqNumber;

// 线程状态
private volatile int threadStatus;

// 用来作为锁的对象
volatile Object parkBlocker;
// 用来作为锁的对象
private final Object blockerLock = new Object();


private volatile Interruptible blocker;

2 构造器

Thread 有许多重载的构造器，但是基本上都只是在值数量上做了封装，核心的构造器逻辑只有一个：

// Thread.class
private Thread(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;

    // currentThread() 方法会获取到当前线程的线程对象
    // 由于当前线程是创建该线程的线程，所以是该线程对象的 父线程
    Thread parent = currentThread();
    
    // 权限控制器
    SecurityManager security = System.getSecurityManager();
    if (g == null) {if (security != null) {g = security.getThreadGroup();
        }

        if (g == null) {
            // 如果没有组的话，会获取到 父线程 的线程组赋值给子线程
            g = parent.getThreadGroup();}
    }

    g.checkAccess();

    // 权限控制器
    if (security != null) {if (isCCLOverridden(getClass())) {
            security.checkPermission(SecurityConstants.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();
    this.target = target;
    setPriority(priority);
    // threadLocal 配置
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals =
        ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    // 栈深度
    this.stackSize = stackSize;

    // 生成一个唯一的线程 id
    this.tid = nextThreadID();}

3 start

start() 方法是 Thread 对象启动新线程的核心方法：

// Thread.class

// step 1
public synchronized void start() {
    
    // 先判断线程的状态，如果线程状态不正确直接抛出错误
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    // 将对象添加到线程组
    group.add(this);

    // 线程是否正常启动的标识对象
    boolean started = false;
    try {
        // 调用 native 的线程启动方法
        start0();
        // 修改标识对象
        started = true;
    } finally {
        try {
            // 如果 started 仍然等于 false
            // 那么此处会在线程组中添加失败信息
            if (!started) {group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {// 此处没有做任何异常处理}
    }
}

// step 2
// native 方法启动线程
private native void start0();

4 sleep

sleep(…) 方法是用来休眠线程的常用方法：

// Thread.class

// step 1
public static void sleep(long millis, int nanos) throws InterruptedException {

    // 此方法中使用者可以输入 毫秒 和 纳秒 两个参数
    // 但是实际上 java 只支持到毫秒级的线程休眠
    // 如果纳秒数大于零，那么就会在毫秒数上 +1，意思是多休眠一毫秒
    // 这个方法预留出来不太清楚具体作用
    
    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 > 0 && millis < Long.MAX_VALUE) {millis++;}
    // 调用 native 的休眠方法
    sleep(millis);
}

// step 2
// native 方法休眠线程
public static native void sleep(long millis) throws InterruptedException;

5 interrupt

interrupt() 方法是用来中断线程的常用方法：

// Thread.class

// step 1
public void interrupt() {
    // 如果当前方法的调用线程不是此线程对象代表的线程，则进入该段逻辑
    // 此处会优先使用 Interruptible(中断器) 去中断当前线程
    // 如果没有配置中断器，那么调用自身的 native 方法去中断线程
    if (this != Thread.currentThread()) {// checkAccess() 方法用于确认权限控制器
        checkAccess();

        synchronized (blockerLock) {
            // 此处可以自定义中断器
            Interruptible b = blocker;
            if (b != null) {b.interrupt(this);
                return;
            }
        }
    }
    
    // 调用 native 的线程中断方法
    interrupt0();}

// step 2
private native void interrupt0();

另外关于线程的中断，还有一些方法：

// 判断当前线程的线程状态
public static boolean interrupted() {// currentThread() 方法会获取到当前线程的线程对象
    // 然后判断此线程对象是否被中断了
    // 如果是被中断的，那么此处恢复线程
    return currentThread().isInterrupted(true);
}

public boolean isInterrupted() {
    // 不会恢复线程的中断状态
    return isInterrupted(false);
}

@HotSpotIntrinsicCandidate
private native boolean isInterrupted(boolean ClearInterrupted);

5 join

join() 方法是用阻塞调用线程，等待对象线程结束之后再执行之后操作的方法：

// Thread.class
// step 1
public final void join() throws InterruptedException {join(0);
}

// step 2
public final synchronized void join(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");
    }

    // 在这里判断 nanos 的值，如果在合理范围内，就在 millis 上加一
    // 这里可知，其实 join(...) 方法并不支持纳秒级别的时间间隔
    if (nanos > 0 && millis < Long.MAX_VALUE) {millis++;}

    // 调用 step 3 中的 join(...) 方法
    join(millis);
}

// step 3
// 核心的 join(...) 方法，具体的阻塞逻辑
public final synchronized void join(final long millis) throws InterruptedException {
    // 如果设置了超时时间，那么超过时间了就会停止阻塞
    if (millis > 0) {if (isAlive()) {final long startTime = System.nanoTime();
            long delay = millis;
            do {wait(delay);
            } while (isAlive() 
                    && (delay = millis - TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime)) > 0);
        }
    } else if (millis == 0) {
        // 不设置超时时间，此处一直等待直到执行完毕
        while (isAlive()) {wait(0);
        }
    } else {throw new IllegalArgumentException("timeout value is negative");
    }
}

由上述源码可知，join(…) 方法的本质是阻塞当前线程，一直到目标的线程对象不再存活 (isAlive() == false) 为止。

6 主要的 native 方法

实际上 Thread 是一个非常底层的类，大多数的方法都是 native 修饰的，即底层调用了 c 语言写的代码。

// 获取当前线程的线程对象
public static native Thread currentThread();

// 让出线程的时间片，即为短暂暂停线程的活动让给其它线程使用
public static native void yield();

7 其它方法

Thread 中还有一些特殊的和预留的方法：

// jdk9 中新加的空方法，暂不清楚用途
 @HotSpotIntrinsicCandidate
 public static void onSpinWait() {}

// 复写了 Object 的 clone() 方法，但是只要被调用就会报错
// 说明 Thread 对象不可被复制
@Override
protected Object clone() throws CloneNotSupportedException {throw new CloneNotSupportedException();
}

// 退出线程，逻辑很简单，即为置空成员变量，帮助 gc
private void exit() {if (threadLocals != null && TerminatingThreadLocal.REGISTRY.isPresent()) {TerminatingThreadLocal.threadTerminated();
    }
    if (group != null) {group.threadTerminated(this);
        group = null;
    }

    target = null;
    threadLocals = null;
    inheritableThreadLocals = null;
    inheritedAccessControlContext = null;
    blocker = null;
    uncaughtExceptionHandler = null;
}

// 判断线程组内活跃的线程数量
public static int activeCount() {return currentThread().getThreadGroup().activeCount();
}

// 设置为守护线程
public final void setDaemon(boolean on) {
    // 此处设置权限
    checkAccess();
    // 如果此线程此时还处于存活状态，那么就会报错
    // 即为，只有线程未启动的时候才能进行守护线程的设置
    if (isAlive()) {throw new IllegalThreadStateException();
    }
    daemon = on;
}

8 线程状态

java 中的线程的状态，以枚举对象的形式存在：

public enum State {
    NEW, // 新建状态，尚未启动
    RUNNABLE, // 可运行状态，即为运行状态
    BLOCKED, // 阻塞状态
    WAITING, // 等待状态
    TIMED_WAITING, // 限时等待状态
    TERMINATED; // 终止状态
}

本文仅为个人的学习笔记，可能存在错误或者表述不清的地方，有缘补充

退出移动版