【JMM】Thread源码分析之线程状态及常用方法

扫码关注公众号:Java 技术驿站

发送:vip
将链接复制到本浏览器,永久解锁本站全部文章

【公众号:Java 技术驿站】 【加作者微信交流技术,拉技术群】

文章首发于:clawhub.club


线程的状态转换

通过源码分析,线程的状态大部分都是用虚拟机设置的,只有在线程新建而未启动的时候,线程的状态值为0,处于State.NEW状态。

2019102910016\_1.png

Java线程状态.png

  • NEW
    新建状态,线程对象新建时的状态。
  • RUNNABLE
    就绪状态,调用了线程的start()方法后,随时等待CPU调度。
  • BLOCKED
    阻塞状态,等待synchronized 锁。
  • WAITING
    当调用了Object.wait,Thread.join,LockSupport.park方法后(没有超时设定),挂起当前线程。
  • TIMED_WAITING
    调用了Thread.sleep,Object.wait,Thread.join,LockSupport.parkUntil,LockSupport.parkNanos有超时设定的方法,挂起当前线程一段时间。
  • TERMINATED
    线程执行结束。

常用方法

currentThread()

获取当前线程的引用,静态方法。

      /**
         * Returns a reference to the currently executing thread object.
         * 返回对当前正在执行的线程对象的引用。
         * @return the currently executing thread.
         */
        public static native Thread currentThread();
sleep(long millis)

睡眠一段时间,让出CPU,线程处于TIMED_WAITING状态。即不参与CPU竞争,即使是sleep(0)。

        /**
         * 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
         *                                  <i>interrupted status</i> of the current thread is
         *                                  cleared when this exception is thrown.
         */
        public static native void sleep(long millis) throws InterruptedException;
yield()

线程调用yield()方法后,线程还是属于RUNNANLE状态,也就是会重新竞争CPU,可能前脚刚让出CPU,后脚就抢回来了。

        /**
         * 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.
         *
         * <p> 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.
         *
         * <p> 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();
isAlive()

判断虚拟机新创建的线程是否存活。

     /**
         * Tests if this thread is alive. A thread is alive if it has
         * been started and has not yet died.
         *
         * @return <code>true</code> if this thread is alive;
         * <code>false</code> otherwise.
         */
        public final native boolean isAlive();
join(long millis)

该方法等待this thread终止,最多等指定的时间,如果指定时间为0,则一直等。即线程可能处于WAITING或TIMED_WAITING状态。

       /**
         * Waits at most {@code millis} milliseconds for this thread to
         * die. A timeout of {@code 0} means to wait forever.
         *
         * <p> This implementation uses a loop of {@code this.wait} calls
         * conditioned on {@code this.isAlive}. As a thread terminates the
         * {@code this.notifyAll} method is invoked. It is recommended that
         * applications not use {@code wait}, {@code notify}, or
         * {@code notifyAll} on {@code Thread} instances.
         *
         * @param millis the time to wait in milliseconds
         * @throws IllegalArgumentException if the value of {@code millis} is negative
         * @throws InterruptedException     if any thread has interrupted the current thread. The
         *                                  <i>interrupted status</i> of the current thread is
         *                                  cleared when this exception is thrown.
         */
        public final synchronized void join(long millis)
                throws InterruptedException {
            long base = System.currentTimeMillis();
            long now = 0;
            if (millis < 0) {
                throw new IllegalArgumentException("timeout value is negative");
            }

            if (millis == 0) {
                while (isAlive()) {
                    wait(0);
                }
            } else {
                while (isAlive()) {
                    long delay = millis - now;
                    if (delay <= 0) {
                        break;
                    }
                    wait(delay);
                    now = System.currentTimeMillis() - base;
                }
            }
        }

以前分析JAVA线程的时候,都会有个running状态,在源码中,RUNNABLE状态即包括了准备被CPU调用状态和正在执行状态。


来源:https://www.jianshu.com/p/347ea7f881f8

赞(0) 打赏
版权归原创作者所有,任何形式的转载请联系博主:daming_90:Java 技术驿站 » 【JMM】Thread源码分析之线程状态及常用方法

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏