Thread类源码解读

﹏ヽ暗。殇╰゛Y 2023-02-17 02:25 7阅读 0赞

本文源码基于jdk1.8 。

**一、创建线程有哪几种方式（实现Runnable接口和继承Thread类）**

## Runnable 接口 ##

我们看Thread类的定义知道，它实现了`Runable`接口

public class Thread implements Runnable {
        ...
    }

而`Runnable`接口的定义如下:

@FunctionalInterface
    public interface Runnable {
        public abstract void run();
    }

**二、如何启动一个线程（调用start方法）**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ljYjE5MTQ4NDU0NTE_size_16_color_FFFFFF_t_70][]

那能不能直接调用对象的run方法？是不行的，如示例

public class Mythread extends Thread {
    	@Override
    	public void run() {
    		System.out.println("当前执行的线程是："+Thread.currentThread().getName());
    	}
    }
    
    public class MyThreadTest {
    	public static void main(String[] args) throws InterruptedException {
    		Mythread thread = new Mythread();
    		
    		//调用start启动线程
    		thread.start();
    		
    		Thread.sleep(1000);
    		
    		//直接调用对象的run方法
    		thread.run();
    	}
    }

输出如下，直接调用run方法，不会产生新线程。

![20200611120904796.png][]

**三、线程状态及状态转换**

在Thread类中, 线程状态是通过`threadStatus`属性以及`State`枚举类实现的:

/* Java thread status for tools,
 * initialized to indicate thread 'not yet started'
 */
 private volatile int threadStatus = 0;
 
 
 public enum State {
 /**
 * Thread state for a thread which has not yet started.
 */
 NEW,
 
 /**
 * Thread state for a runnable thread. A thread in the runnable
 * state is executing in the Java virtual machine but it may
 * be waiting for other resources from the operating system
 * such as processor.
 */
 RUNNABLE,
 
 /**
 * Thread state for a thread blocked waiting for a monitor lock.
 * A thread in the blocked state is waiting for a monitor lock
 * to enter a synchronized block/method or
 * reenter a synchronized block/method after calling
 * {@link Object#wait() Object.wait}.
 */
 BLOCKED,
 
 /**
 * Thread state for a waiting thread.
 * A thread is in the waiting state due to calling one of the
 * following methods:
 * <ul>
 * <li>{@link Object#wait() Object.wait} with no timeout</li>
 * <li>{@link #join() Thread.join} with no timeout</li>
 * <li>{@link LockSupport#park() LockSupport.park}</li>
 * </ul>
 *
 * A thread in the waiting state is waiting for another thread to
 * perform a particular action.
 *
 * For example, a thread that has called <tt>Object.wait()</tt>
 * on an object is waiting for another thread to call
 * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
 * that object. A thread that has called <tt>Thread.join()</tt>
 * is waiting for a specified thread to terminate.
 */
 WAITING,
 
 /**
 * Thread state for a waiting thread with a specified waiting time.
 * A thread is in the timed waiting state due to calling one of
 * the following methods with a specified positive waiting time:
 * <ul>
 * <li>{@link #sleep Thread.sleep}</li>
 * <li>{@link Object#wait(long) Object.wait} with timeout</li>
 * <li>{@link #join(long) Thread.join} with timeout</li>
 * <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
 * <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
 * </ul>
 */
 TIMED_WAITING,
 
 /**
 * Thread state for a terminated thread.
 * The thread has completed execution.
 */
 TERMINATED;
 }
 
 /**
 * Returns the state of this thread.
 * This method is designed for use in monitoring of the system state,
 * not for synchronization control.
 *
 * @return this thread's state.
 * @since 1.5
 */
 public State getState() {
 // get current thread state
 return sun.misc.VM.toThreadState(threadStatus);
 }

从源码中可以看出, 线程一共有6种状态, 其状态转换关系如下图所示:

![线程状态转换][format_png]

**四、几个方法源码解读**

**currentThread**

源码中currentThread定义如下：

/**
         * Returns a reference to the currently executing thread object.
         *
         * @return  the currently executing thread.
         */
        @HotSpotIntrinsicCandidate
        public static native Thread currentThread();

可见，它是一个静态方法，并且是一个native方法，返回的是**当前正在执行的线程**。这里"当前正在执行的线程"指的是**当前正在执行这段代码的线程**。

### sleep ###

谈起sleep方法, 被问的最多的两个问题就是:

1.  Thread.sleep() 与 Thread.currentThread().sleep() 有什么区别？
2.  Thread.sleep() 和 Object.wait()有什么区别?

这些问题的答案, 你在源码里都能找得到。我们直接来看源码:

/**
 * Causes the currently executing thread to sleep (temporarily cease
 * execution) for the specified number of milliseconds, subject to
 * the precision and accuracy of system timers and schedulers. The thread
 * does not lose ownership of any monitors.
 *
 * @param millis
 * the length of time to sleep in milliseconds
 *
 * @throws IllegalArgumentException
 * if the value of {@code millis} is negative
 *
 * @throws InterruptedException
 * if any thread has interrupted the current thread. The
 * interrupted status of the current thread is
 * cleared when this exception is thrown.
 */
 public static native void sleep(long millis) throws InterruptedException;

从源码可知，sleep方法也是一个静态方法，并且时native方法，从注释`Causes the currently executing thread to sleep可以看出，它作用于当前正在执行的线程，`这里"当前正在执行的线程"指的是**当前正在执行这段代码的线程**。

> Thread.sleep() 与 Thread.currentThread().sleep() 没有区别

另外, 上面的注释中还有一句非常重要的话:

> The thread does not lose ownership of any monitors.

也就是说, **虽然sleep函数使当前线程让出了CPU, 但是, 不释放所持有的监视器锁, 这与同时让出CPU资源和监视器锁资源的wait方法是不一样的。**

异常 InterruptedException

> @throws InterruptedException 
> \* if any thread has interrupted the current thread. The 
> \* interrupted status of the current thread is 
> \* cleared when this exception is thrown.

sleep期间如果任何线程中断了当前线程，将会抛出InterruptedException异常，抛出异常的同时，interrupted status **将会被清除。**

**yield**

/**
 * A hint to the scheduler that the current thread is willing to yield
 * its current use of a processor. The scheduler is free to ignore this
 * hint.
 *
 * Yield is a heuristic attempt to improve relative progression
 * between threads that would otherwise over-utilise a CPU. Its use
 * should be combined with detailed profiling and benchmarking to
 * ensure that it actually has the desired effect.
 *
 * It is rarely appropriate to use this method. It may be useful
 * for debugging or testing purposes, where it may help to reproduce
 * bugs due to race conditions. It may also be useful when designing
 * concurrency control constructs such as the ones in the
 * {@link java.util.concurrent.locks} package.
 */
 public static native void yield();

yield方法是一个native方法, 从注释（`hint to the scheduler that the current thread is willing to yield its current use of a processor. The scheduler is free to ignore this hint)可以看出.` 它对于CPU只是一个**建议**, 告诉CPU, 当前线程愿意让出CPU给其他线程使用, 至于CPU采不采纳, 取决于不同厂商的行为, 有可能一个线程刚yield出CPU, 然后又立马获得了CPU。与之相对, sleep方法一定会让出CPU资源, 并且休眠指定的时间, 不参与CPU的竞争.

所以调用yield方法不会使线程退出**`RUNNANLE`**状态，顶多会使线程从**running 变成 ready**，但是sleep方法是有可能将线程状态转换成`TIMED_WAITING`的。

**五、线程中断，interrupt**

线程中断是一个很重要的概念，通常，取消一个任务的执行，最好的，同时也是最合理的方法，就是通过中断

**在Thread线程类里面，并没有中断标志位的属性，但是提供了获取中断标志位的接口:**

/**
         * Tests if some Thread has been interrupted.  The interrupted state
         * is reset or not based on the value of ClearInterrupted that is
         * passed.
         */
        @HotSpotIntrinsicCandidate
        private native boolean isInterrupted(boolean ClearInterrupted);

这是一个native方法，同时也是一个**private方法**，该方法除了能够返回当前线程的中断状态，还能根据**`ClearInterrupted`**参数来决定要不要重置中断标志位，ClearInterrupted为true，重置中断标志位。

**Thread类提供了两个public方法来使用该private native 方法:**

/**
 * Tests whether the current thread has been interrupted. The
 * interrupted status of the thread is cleared by this method. In
 * other words, if this method were to be called twice in succession, the
 * second call would return false (unless the current thread were
 * interrupted again, after the first call had cleared its interrupted
 * status and before the second call had examined it).
 *
 * A thread interruption ignored because a thread was not alive
 * at the time of the interrupt will be reflected by this method
 * returning false.
 *
 * @return {@code true} if the current thread has been interrupted;
 * {@code false} otherwise.
 * @see #isInterrupted()
 * @revised 6.0
 */
 public static boolean interrupted() {
 return currentThread().isInterrupted(true);
 }
 
 /**
 * Tests whether this thread has been interrupted. The interrupted
 * status of the thread is unaffected by this method.
 *
 * A thread interruption ignored because a thread was not alive
 * at the time of the interrupt will be reflected by this method
 * returning false.
 *
 * @return {@code true} if this thread has been interrupted;
 * {@code false} otherwise.
 * @see #interrupted()
 * @revised 6.0
 */
 public boolean isInterrupted() {
 return isInterrupted(false);
 }

**static 方法**，此方法调用时会重置线程的中断状态，非static方法不会重置中断标识

个人记录

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ljYjE5MTQ4NDU0NTE_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200610232049287.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ljYjE5MTQ4NDU0NTE=,size_16,color_FFFFFF,t_70
[20200611120904796.png]: https://img-blog.csdnimg.cn/20200611120904796.png
[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9zZWdtZW50ZmF1bHQuY29tL2ltZy9yZW1vdGUvMTQ2MDAwMDAxNjA1NjQ3NA?x-oss-process=image/format,png