多线程源码--Thread源码

前言

　　Java.lang.Thread是Java应用程序员对Java多线程的第一站，Thread就是对Java线程本身的抽象

　　所以在Java中的线程编程概念中，一个Thread实例 == 一个线程
　　线程有哪些属性、行为，Thread大致就有哪些属性、行为。

源码

构造器

　　

public Thread() { init(null, null, "Thread-" + nextThreadNum(), 0); }
public Thread(Runnable target) { init(null, target, "Thread-" + nextThreadNum(), 0); }
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); }
Thread(Runnable target, AccessControlContext acc) { init(null, target, "Thread-" + nextThreadNum(), 0, acc, false); }

从上面可以看出，所有的构造器都依赖着init方法

　　private void init(ThreadGroup g, Runnable target, String name,long stackSize)

除了上面列表的最后一个构造器外，其他构造器传递的参数，都在上面 init() 方法参数只能。这几个参数的解释如下：

ThreadGroup 线程组；

Runnable 封装线程任务；

String name 线程名称；

long stackSize 虚拟机栈的空间大小，默认为0，不设置 即忽略它。

现在来说说与构造器相关的 init() 方法源码

 

由上图可见，大多数构造器（就是除上面最后一个），都是先将数据传递上图第一个init方法，然后内部再次调用它的重载方法。我们来看看这个方法源码

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(); //父线程，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(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); //设置优先级
        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        //保存指定的堆栈大小
        this.stackSize = stackSize;

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

属性

    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;
    //线程任务
    private Runnable target;
    //线程组
    private ThreadGroup group;
    //此线程的上下文类装入器
    private ClassLoader contextClassLoader;
    //它封装的上下文做出系统资源访问决策。
    private AccessControlContext inheritedAccessControlContext;

    //自动编号。就是当没有设置线程名称的时候。我们看到的Thread-0 Thread-1
    private static int threadInitNumber;
    private long stackSize; //线程堆栈空间大小，默认0，不用管

    //jvm私有状态，在本机线程终止后仍然存在。
    private long nativeParkEventPointer;
    private long tid; //线程ID

    //用于生成线程ID
    private static long threadSeqNumber;
    private volatile int threadStatus = 0;//线程初始状态。表示线程尚未启动
    volatile Object parkBlocker;
    private volatile Interruptible blocker;
    private final Object blockerLock = new Object();//用于synchronized关键字的实例锁
    public final static int MIN_PRIORITY = 1;//最小优先级
    public final static int NORM_PRIORITY = 5;//默认优先级
    public final static int MAX_PRIORITY = 10;//最大优先级

常用的关键方法

start()启动方法

public synchronized void start() {
        //零状态值对应于状态“NEW”。
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        //添加到线程组
        group.add(this);
        boolean started = false;
        try {
            start0();//这个方法是本地方法，意思启动线程
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                //什么也不做。如果start0抛出一个投掷物它将被传递到调用堆栈

            }
        }
    }

private native void start0(); //start0本地方法

run()运行方法

public void run() {
　　　　 //线程任务不为空时，调用父接口的run方法
        if (target != null) {
            target.run();
        }
    }

exit()退出方法

//清除必要的资源
private void exit() {
        if (group != null) {
            group.threadTerminated(this);
            group = null;
        }
        target = null;
        threadLocals = null;
        inheritableThreadLocals = null;
        inheritedAccessControlContext = null;
        blocker = null;
        uncaughtExceptionHandler = null;
    }

interrupt()中断方法

public void interrupt() {
        if (this != Thread.currentThread())
            checkAccess();//权限检查
        synchronized (blockerLock) {
            Interruptible b = blocker; //设置中断接口
            if (b != null) {
                interrupt0(); // 设置中断标志
                b.interrupt(this);
                return;
            }
        }
        interrupt0();
    }
//interrupt0()是本地方法

interrupted() 是否已中断

public static boolean interrupted() {
        return currentThread().isInterrupted(true);
    }
public boolean isInterrupted() {
        return isInterrupted(false);
    }
private native boolean isInterrupted(boolean ClearInterrupted);

线程是否被激活isAlive()

public final native boolean isAlive();

线程优先级相关方法

//优先级设置
public final void setPriority(int newPriority) {
        ThreadGroup g;
        checkAccess();//权限效验
        if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) { //优先级超出范围内，抛出异常
            throw new IllegalArgumentException();
        }
        if((g = getThreadGroup()) != null) {
            if (newPriority > g.getMaxPriority()) { //传递的优先级数超过线程组的最大范围，将其设置最大值
                newPriority = g.getMaxPriority();
            }
            setPriority0(priority = newPriority); //如果没有超过，调用本地方法设置优先级
        }
    }
//返回优先级
public final int getPriority() {
     return priority;
}

线程名称

//名称设置
public final synchronized void setName(String name) {
        checkAccess();
        if (name == null) { //为空，抛出异常
            throw new NullPointerException("name cannot be null");
        }

        this.name = name;
        if (threadStatus != 0) { //线程已启动
            setNativeName(name);  //调用本地方法设置名称
        }
    }
//返回名称
public final String getName() {
        return name;
    }

---

public final ThreadGroup getThreadGroup() { return group; }  //返回线程组

public static int activeCount() { return currentThread().getThreadGroup().activeCount(); } //返回线程组活动的线程数

public static int enumerate(Thread tarray[]) { return currentThread().getThreadGroup().enumerate(tarray); }  //线程组添加线程集合

public static native void yield();  //暂停一下线程，回到就绪状态

---

join()方法

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) {  //传递参数小于0，抛异常
            throw new IllegalArgumentException("timeout value is negative");
        }
　　　　 //参数为0
        if (millis == 0) {
            while (isAlive()) {  //线程处于运行状态
                wait(0);  //调用Object的wait方法
            }
        } else {  //如果参数大于0 
            while (isAlive()) {
                long delay = millis - now; 
                if (delay <= 0) {  //当前时间不能大于设置的时间之后的时间
                    break;
                }
                wait(delay); //调用Object的wait方法
                now = System.currentTimeMillis() - base; //当前时间
            }
        }
    }
public final synchronized void join(long millis, int nanos) throws InterruptedException {
        if (millis < 0) { //不可小于0
            throw new IllegalArgumentException("timeout value is negative");
        }
        if (nanos < 0 || nanos > 999999) { //纳秒不可超过规定范围
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }
　　　　  //如果纳秒符合条件，秒自增1
        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }
        join(millis); //调用上面的方法
    }

sleep()方法

public static void sleep(long millis, int nanos) throws InterruptedException {
        if (millis < 0) { //参数必须大于0
            throw new IllegalArgumentException("timeout value is negative");
        }
        if (nanos < 0 || nanos > 999999) { //纳秒要在规定范围
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }
　　　　 //如果纳秒符合条件，秒自增1
        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }
        sleep(millis); //调用本地方法
    }

public static native void sleep(long millis) throws InterruptedException;  //本地方法

Daemon相关方法

public final void setDaemon(boolean on) {  //设置是否为守护线程
        checkAccess(); //权限效验
        if (isAlive()) {  //当前线程不能为激活状态
            throw new IllegalThreadStateException();
        }
        daemon = on;  //设置当前线程是否为守护线程
    }
//是否为守护线程
public final boolean isDaemon() {
        return daemon;
    }

以上就是常用的api源码，个人能力不足，还请见谅，待之后进行完善。