Java中Thread源码剖析

本文来自http://blog.csdn.net/liuxian13183/ ，引用必须注明出处！

关于线程，用很长时间了，主线程下的子线程去做一些事情，就是一个代理模式，主线程分代理权给子线程，子线程帮主线程完成一些任务。

线程的方法大部分都是使用Native使用，不允许应用层修改，是CPU调度的最基本单元。实现线程的方式有三种：使用内核线程、用户线程和混合线程来实现，奉行先行发生的原则。

内核线程：每个生成的线程，都1：1配比一个内核线程来支持，即双线程机制，消耗一个内核资源，类似手机中应用进程

用户线程：普通线程，高速且低耗，创建、切换、调度等问题都需要自己处理

混合实现：降低被阻塞的风险，用户线程与内核线程相当于M:N的关系

线程的调度方式主要有两种：协同式和抢占式，前者简单但不可控制，一个线程执行完通知另外一个；抢占式可以通过yield方法让出执行时间，Java目前就采用这种，同时可以使用设置优先级的方式来提前线程执行顺序，但有可能被“系统”关闭。

今天我们来看下线程的源码，进行系统的学习。

1、首先线程有六种状态

public enum State {
        /**
         * The thread has been created, but has never been started.
         */
        NEW,
        /**
         * The thread may be run.
         */
        RUNNABLE,
        /**
         * The thread is blocked and waiting for a lock.
         */
        BLOCKED,
        /**
         * The thread is waiting.
         */
        WAITING,
        /**
         * The thread is waiting for a specified amount of time.
         */
        TIMED_WAITING,
        /**
         * The thread has been terminated.
         */
        TERMINATED
    }

NEW:刚创建还没启动

RUNNABLE:可以执行

BLOCKED:堵塞状态，等待持有锁

WAITING :处理等待状态

TIMED_WAITING:等待一些时间

TERMINATED:终止

/**
     * The maximum priority value allowed for a thread.
     */
    public static final int MAX_PRIORITY = 10;

/**
     * The minimum priority value allowed for a thread.
     */
    public static final int MIN_PRIORITY = 1;

/**
     * The normal (default) priority value assigned to threads.
     */
    public static final int NORM_PRIORITY = 5;

2、分别是线程可设置的最大、最小和默认优先级，级别越高执行越靠前

/**
     * Holds the thread's ID. We simply count upwards, so
     * each Thread has a unique ID.
     */
    private long id;

3、每个线程都有一个独一无二的ID

public Thread() {
        create(null, null, null, 0);
    }

private void create(ThreadGroup group, Runnable runnable, String threadName, long stackSize) {
        Thread currentThread = Thread.currentThread();
        if (group == null) {
            group = currentThread.getThreadGroup();
        }

if (group.isDestroyed()) {
            throw new IllegalThreadStateException("Group already destroyed");
        }

this.group = group;

synchronized (Thread.class) {
            id = ++Thread.count;
        }

if (threadName == null) {
            this.name = "Thread-" + id;
        } else {
            this.name = threadName;
        }

this.target = runnable;
        this.stackSize = stackSize;

this.priority = currentThread.getPriority();

this.contextClassLoader = currentThread.contextClassLoader;

// Transfer over InheritableThreadLocals.
        if (currentThread.inheritableValues != null) {
            inheritableValues = new ThreadLocal.Values(currentThread.inheritableValues);
        }
        // add ourselves to our ThreadGroup of choice
        this.group.addThread(this);
    }

4、初始化一个空的线程，获得当前运行的线程群组，设置id,name,执行线程runnable,池大小stackSize,优先级，并加入到线程群组，这是一个无参的Thread，正常情况下应该有ThreadGroup、Runnable、threadName和stackSize这四个参数。一般threadName如果为空，则报出NullPointerException,stackSize默认为0。

/**
     * Destroys the receiver without any monitor cleanup.
     *
     * @deprecated Not implemented.
     */
    @Deprecated
    public void destroy() {
        throw new NoSuchMethodError("Thread.destroy()"); // TODO Externalize???
    }

5、destroy方法在java7已经被抛弃。

public void interrupt() {
        synchronized (interruptActions) {
            for (int i = interruptActions.size() - 1; i >= 0; i--) {
                interruptActions.get(i).run();
            }
        }

VMThread vmt = this.vmThread;
        if (vmt != null) {
            vmt.interrupt();
        }
    }

6、停止当前线程，如果线程处于wait、join、sleep状态的线程，会报异常。

public final boolean isAlive() {
        return (vmThread != null);
    }

7、线程是否死掉，主要是判断虚拟机线程有没有死掉VMThread，当然获得当前线程也是通过VMThread.currentThread()，以及接下下获得当前线程处于六大状态中的哪种。

public State getState() {
        // TODO This is ugly and should be implemented better.
        VMThread vmt = this.vmThread;

// Make sure we have a valid reference to an object. If native code
        // deletes the reference we won't run into a null reference later.
        VMThread thread = vmThread;
        if (thread != null) {
            // If the Thread Object became invalid or was not yet started,
            // getStatus() will return -1.
            int state = thread.getStatus();
            if(state != -1) {
                return VMThread.STATE_MAP[state];
            }
        }
        return hasBeenStarted ? Thread.State.TERMINATED : Thread.State.NEW;
    }

public final void join() throws InterruptedException {
        VMThread t = vmThread;
        if (t == null) {
            return;
        }

synchronized (t) {
            while (isAlive()) {
                t.wait();
            }
        }
    }

8、join堵塞当前线程，使其处于等待状态，因为子线程执行的时间可能比主线程执行时间还长，所以join是主线程需要在它执行完后再销毁。当然也可以加参数join(long millis, int nanos)，使其等待N秒N毫秒，如果它已经处于join方法，则报InterruptedException 。

public final void setDaemon(boolean isDaemon) {
        if (hasBeenStarted) {
            throw new IllegalThreadStateException("Thread already started."); // TODO Externalize?
        }

if (vmThread == null) {
            daemon = isDaemon;
        }
    }

9、设置为守护线程，必须的runnable执行前设置，会在其他已经没有非守护线程运行的时候执行。

public final void setPriority(int priority) {
        if (priority < Thread.MIN_PRIORITY || priority > Thread.MAX_PRIORITY) {
            throw new IllegalArgumentException("Priority out of range"); // TODO Externalize?
        }

if (priority > group.getMaxPriority()) {
            priority = group.getMaxPriority();
        }

this.priority = priority;

VMThread vmt = this.vmThread;
        if (vmt != null) {
            vmt.setPriority(priority);
        }
    }

10、优先级主要通过VMThread来设置的，注意最高设为10最低为1，否则报 IllegalArgumentException。

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

        VMThread.sleep(millis, nanos);

}

11、执行sleep，如果在sleep期间被interrupt,会报InterruptedException。

/**
     * Starts the new Thread of execution. The <code>run()</code> method of
     * the receiver will be called by the receiver Thread itself (and not the
     * Thread calling <code>start()</code>).
     *
     * @throws IllegalThreadStateException if the Thread has been started before
     *
     * @see Thread#run
     */
    public synchronized void start() {
        if (hasBeenStarted) {
            throw new IllegalThreadStateException("Thread already started."); // TODO Externalize?
        }

hasBeenStarted = true;

VMThread.create(this, stackSize);
    }

12、线程开始执行，如果start已经执行，则报IllegalThreadStateException

@Deprecated
    public final synchronized void stop(Throwable throwable) {
        throw new UnsupportedOperationException();
    }

13、stop方法弃用

public static void yield() {
        VMThread.yield();
    }

14、给另一个准备运行的线程让路，让它先执行

关于join和yield的区别，更在上一节：

Java中join和yield的作用