关于java:面经手册-第20篇Thread-线程状态转换方法使用原理分析

36次阅读

共计 9532 个字符,预计需要花费 24 分钟才能阅读完成。

作者:小傅哥
<br/> 博客:https://bugstack.cn
<br/>Github:https://github.com/fuzhengwei/CodeGuide/wiki

积淀、分享、成长,让本人和别人都能有所播种!????

一、前言

考不罕用的、考你不会的、考你疏忽的,才是考试!

大部分考试考的,根本都是不怎么用的。例外的咱们不说???? 就像你做程序开发,尤其在 RPC+MQ+ 分库分表,其实很难呈现让你用一个机器实例编写多线程压迫 CPU 性能。很多时候是扔出一个 MQ,异步生产了。如果没有资源竞争,例如库表秒杀,那么其实你的确很难接触多并发编程以及锁的应用。

但!凡有例外,比方你须要开发一个数据库路由中间件,那么就必定会呈现在一台利用实例上调配数据库资源池的状况,如果呈现竞争就要正当分配资源。如此,相似这样的中间件开发,就会波及到一些更外围底层的技术的利用。

所以,有时候不是 没用 ,而是你没有

二、面试题

谢飞机,小记! 线程我玩定了,面试也拦不住我,我说的!

谢飞机:嘿,你好哇,我是谢飞机!

面试官:好,明天电话面试,你筹备好了?

谢飞机:筹备好了,嘿嘿!

面试官:嗯,我看你简历里写了不少线程的货色,看来理解的不错。问你一个线程吧那就,线程之间状态是怎么转换的?

谢飞机:扒拉扒拉,扒拉扒拉!

面试官:嗯,还不错。那 yield 办法是怎么应用的。

谢飞机:嗯!如同是让出 CPU。具体的没怎么用过!

面试官:做做测试,验证下,下次问你。

三、Thread 状态关系

Java 的线程状态形容在枚举类 java.lang.Thread.State 中,共包含如下五种状态:

public enum State {NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED;}

这五种状态形容了一个线程的生命周期,其实这种状态码的定义在咱们日常的业务开发中,也经常出现。比方:一个流动的提交、审核、回绝、批改、通过、运行、敞开等,是相似的。那么线程的状态是通过下图的形式进行流转的,如图 20-1

  • New:新创建的一个线程,处于期待状态。
  • Runnable:可运行状态,并不是曾经运行,具体的线程调度各操作系统决定。在 Runnable 中蕴含了 ReadyRunning 两个状态,当线程调用了 start() 办法后,线程则处于就绪 Ready 状态,期待操作系统调配 CPU 工夫片,调配后则进入 Running 运行状态。此外当调用 yield() 办法后,只是 谦让 的容许以后线程让出 CPU,但具体让不让不肯定,由操作系统决定。如果让了,那么以后线程则会处于 Ready 状态持续竞争 CPU,直至执行。
  • Timed_waiting:指定工夫内让出 CPU 资源,此时线程不会被执行,也不会被系统调度,直到等待时间到期后才会被执行。下列办法都能够触发:Thread.sleepObject.waitThread.joinLockSupport.parkNanosLockSupport.parkUntil
  • Wating:可被唤醒的期待状态,此时线程不会被执行也不会被系统调度。此状态能够通过 synchronized 取得锁,调用 wait 办法进入期待状态。最初通过 notify、notifyall 唤醒。下列办法都能够触发:Object.waitThread.joinLockSupport.park
  • Blocked:当产生锁竞争状态下,没有取得锁的线程会处于挂起状态。例如 synchronized 锁,先取得的先执行,没有取得的进入阻塞状态。
  • Terminated:这个是终止状态,从 New 到 Terminated 是不可逆的。个别是程序流程失常完结或者产生了异样。

这里参考枚举State 类的英文正文理解了每一个状态码的含意,接下来咱们去尝试操作线程办法,把这些状态体现进去。

四、Thread 状态测试

1. NEW

Thread thread = new Thread(() -> {});
System.out.println(thread.getState());

// NEW
  • 这个状态很简略,就是线程创立还没有启动时就是这个状态。

2. RUNNABLE

Thread thread = new Thread(() -> {});
// 启动
thread.start();
System.out.println(thread.getState());

// RUNNABLE
  • 创立的线程启动后 start(),就会进入 RUNNABLE 状态。但此时并不一定在执行,而是说这个线程曾经就绪,能够竞争 CPU 资源。

3. BLOCKED

Object obj = new Object();
new Thread(() -> {synchronized (obj) {
        try {Thread.sleep(10000);
        } catch (InterruptedException e) {e.printStackTrace();
        }
    }
}).start();

Thread thread = new Thread(() -> {synchronized (obj) {
        try {obj.wait();
        } catch (InterruptedException e) {e.printStackTrace();
        }
    }
});

thread.start();
while (true) {Thread.sleep(1000);
    System.out.println(thread.getState());
}

// BLOCKED
// BLOCKED
// BLOCKED
  • 这段代码略微有点长,次要是为了让两个线程产生锁竞争。
  • 第一个线程,synchronized 获取锁后休眠,不开释锁。
  • 第二个线程,synchronized 获取不到锁,会被挂起。
  • 那么最初的输入后果就会是,BLOCKED

4. WAITING

Object obj = new Object();
Thread thread = new Thread(() -> {synchronized (obj) {
        try {obj.wait();
        } catch (InterruptedException e) {e.printStackTrace();
        }
    }
});

thread.start();

while (true) {Thread.sleep(1000);
    System.out.println(thread.getState());
}

// WAITING
// WAITING
// WAITING
  • 只有在 synchronized 代码块或者润饰的办法中,调用 wait 办法,又没有被 notify 就会进入 WAITING 状态。
  • 另外 Thread.join 源码中也是调用的 wait 办法,所以也会让线程进入期待状态。

5. Timed_waiting

Object obj = new Object();
Thread thread = new Thread(() -> {synchronized (obj) {
        try {Thread.sleep(100000);
        } catch (InterruptedException e) {e.printStackTrace();
        }
    }
});
thread.start();

while (true) {Thread.sleep(1000);
    System.out.println(thread.getState());
}

// TIMED_WAITING
// TIMED_WAITING
// TIMED_WAITING
  • 有了下面状态获取的比照,这个状态的获取就没什么难度了。只有改成 Thread.sleep(100000); 就能够了。

6. Terminated

Thread thread = new Thread(() -> {});
thread.start();

System.out.println(thread.getState());
System.out.println(thread.getState());
System.out.println(thread.getState());

// RUNNABLE
// TERMINATED
// TERMINATED
  • 这个就比较简单了,只有一个线程运行完,它的生命周期完结了,就进入了 TERMINATED 状态。

五、Thread 办法应用

个别状况下 Thread 中最罕用的办法就是 start 启动,除此之外一些其余办法可能在平时的开发中用的不多,但这些办法在一些框架中却经常出现。因而只理解它们的概念,然而却短少一些实例来参考! 接下来咱们就来做一些案例来验证这些办法,包含:yield、wait、notify、join。

1. yield

yield 办法让出 CPU,但不肯定,肯定让出!。这种可能会用在一些同时启动的线程中,依照优先级保障重要线程的执行,也能够是其余一些非凡的业务场景(例如这个线程内容很耗时,又不那么重要,能够放在前面)。

为了验证这个办法,咱们做一个例子:启动 50 个线程进行,每个线程都进行 1000 次的加和计算。其中 10 个线程会执行让出 CPU 操作。那么,如果让出 CPU 那 10 个线程的计算加和工夫都比拟长,阐明的确在进行让出操作。

案例代码

private static volatile Map<String, AtomicInteger> count = new ConcurrentHashMap<>();
static class Y implements Runnable {
    private String name;
    private boolean isYield;
    public Y(String name, boolean isYield) {
        this.name = name;
        this.isYield = isYield;
    }
    @Override
    public void run() {long l = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {if (isYield) Thread.yield();
            AtomicInteger atomicInteger = count.get(name);
            if (null == atomicInteger) {count.put(name, new AtomicInteger(1));
                continue;
            }
            atomicInteger.addAndGet(1);
            count.put(name, atomicInteger);
        }
        System.out.println("线程编号:" + name + "执行实现耗时:" + (System.currentTimeMillis() - l) + "(毫秒)" + (isYield ? "让出 CPU----------------------" : "不让 CPU"));
    }
}

public static void main(String[] args) {for (int i = 0; i < 50; i++) {if (i < 10) {new Thread(new Y(String.valueOf(i), true)).start();
            continue;
        }
        new Thread(new Y(String.valueOf(i), false)).start();}
}

测试后果

线程编号:10 执行实现耗时:2 (毫秒)不让 CPU
线程编号:11 执行实现耗时:2 (毫秒)不让 CPU
线程编号:15 执行实现耗时:1 (毫秒)不让 CPU
线程编号:14 执行实现耗时:1 (毫秒)不让 CPU
线程编号:19 执行实现耗时:1 (毫秒)不让 CPU
线程编号:18 执行实现耗时:1 (毫秒)不让 CPU
线程编号:22 执行实现耗时:0 (毫秒)不让 CPU
线程编号:26 执行实现耗时:0 (毫秒)不让 CPU
线程编号:27 执行实现耗时:1 (毫秒)不让 CPU
线程编号:30 执行实现耗时:0 (毫秒)不让 CPU
线程编号:31 执行实现耗时:0 (毫秒)不让 CPU
线程编号:34 执行实现耗时:1 (毫秒)不让 CPU
线程编号:12 执行实现耗时:1 (毫秒)不让 CPU
线程编号:16 执行实现耗时:1 (毫秒)不让 CPU
线程编号:13 执行实现耗时:1 (毫秒)不让 CPU
线程编号:17 执行实现耗时:1 (毫秒)不让 CPU
线程编号:20 执行实现耗时:0 (毫秒)不让 CPU
线程编号:23 执行实现耗时:0 (毫秒)不让 CPU
线程编号:21 执行实现耗时:0 (毫秒)不让 CPU
线程编号:25 执行实现耗时:1 (毫秒)不让 CPU
线程编号:24 执行实现耗时:1 (毫秒)不让 CPU
线程编号:28 执行实现耗时:0 (毫秒)不让 CPU
线程编号:38 执行实现耗时:0 (毫秒)不让 CPU
线程编号:39 执行实现耗时:0 (毫秒)不让 CPU
线程编号:37 执行实现耗时:1 (毫秒)不让 CPU
线程编号:40 执行实现耗时:0 (毫秒)不让 CPU
线程编号:44 执行实现耗时:0 (毫秒)不让 CPU
线程编号:36 执行实现耗时:1 (毫秒)不让 CPU
线程编号:42 执行实现耗时:1 (毫秒)不让 CPU
线程编号:45 执行实现耗时:1 (毫秒)不让 CPU
线程编号:43 执行实现耗时:1 (毫秒)不让 CPU
线程编号:46 执行实现耗时:0 (毫秒)不让 CPU
线程编号:47 执行实现耗时:0 (毫秒)不让 CPU
线程编号:35 执行实现耗时:0 (毫秒)不让 CPU
线程编号:33 执行实现耗时:0 (毫秒)不让 CPU
线程编号:32 执行实现耗时:0 (毫秒)不让 CPU
线程编号:41 执行实现耗时:0 (毫秒)不让 CPU
线程编号:48 执行实现耗时:1 (毫秒)不让 CPU
线程编号:6 执行实现耗时:15 (毫秒)让出 CPU----------------------
线程编号:7 执行实现耗时:15 (毫秒)让出 CPU----------------------
线程编号:49 执行实现耗时:2 (毫秒)不让 CPU
线程编号:29 执行实现耗时:1 (毫秒)不让 CPU
线程编号:2 执行实现耗时:17 (毫秒)让出 CPU----------------------
线程编号:1 执行实现耗时:11 (毫秒)让出 CPU----------------------
线程编号:4 执行实现耗时:15 (毫秒)让出 CPU----------------------
线程编号:8 执行实现耗时:12 (毫秒)让出 CPU----------------------
线程编号:5 执行实现耗时:12 (毫秒)让出 CPU----------------------
线程编号:9 执行实现耗时:12 (毫秒)让出 CPU----------------------
线程编号:0 执行实现耗时:21 (毫秒)让出 CPU----------------------
线程编号:3 执行实现耗时:21 (毫秒)让出 CPU----------------------
  • 从测试后果能够看到,那些让出 CPU 的,执行完计算曾经在 10 毫秒以上,阐明咱们的测试是成果的。

2. wait & notify

wait 和 notify/nofityall,是一对办法,有一个期待,就会有一个叫醒,否则程序就夯在那不动了。对于这部分会应用到的 synchronized 在之前小傅哥有深刻的源码剖析,讲到它是怎么加锁在对象头的,如果你遗记了能够翻翻看《synchronized 解毒,分析源码深度剖析!》

接下来咱们模仿鹿鼎记·丽春院,清倌喝茶吟诗聊风月日常。当有达官贵人来时,须要调配清倌给大老爷。两头会有一些期待、叫醒操作。只为让你更好的记住这样的案例,不要想歪喽。清倌人即是只卖艺欢场人,喊麦的。

案例代码

public class 丽春院 {public static void main(String[] args) {老鸨 鸨子 = new 老鸨();

        清倌 miss = new 清倌(鸨子);
        客官 guest = new 客官(鸨子);

        Thread t_miss = new Thread(miss);
        Thread t_guest = new Thread(guest);

        t_miss.start();
        t_guest.start();}

}

class 清倌 implements Runnable {

    老鸨 鸨子;

    public 清倌(老鸨 鸨子) {this. 鸨子 = 鸨子;}

    @Override
    public void run() {
        int i = 1;
        while (true) {
            try {Thread.sleep(1000);
            } catch (InterruptedException e1) {e1.printStackTrace();
            }
            if (i == 1) {
                try {鸨子. 在岗清倌("苍原野子", "500 日元");
                } catch (InterruptedException e) {e.printStackTrace();
                }
            } else {
                try {鸨子. 在岗清倌("花田岗子", "800 日元");
                } catch (InterruptedException e) {e.printStackTrace();
                }
            }
            i = (i + 1) % 2;
        }
    }

}

class 客官 implements Runnable {

    老鸨 鸨子;

    public 客官(老鸨 鸨子) {this. 鸨子 = 鸨子;}

    @Override
    public void run() {while (true) {
            try {Thread.sleep(1000);
            } catch (InterruptedException e1) {e1.printStackTrace();
            }
            try {鸨子. 喝茶吟诗聊风月();
            } catch (InterruptedException e) {e.printStackTrace();
            }
        }
    }

}

class 老鸨 {

    private String 清倌 = null;
    private String price = null;
    private boolean 工作状态 = true;

    public synchronized void 在岗清倌(String 清倌, String price) throws InterruptedException {if (! 工作状态)
            wait();// 期待
        this. 清倌 = 清倌;
        this.price = price;
        工作状态 = false;
        notify();// 叫醒}

    public synchronized void 喝茶吟诗聊风月() throws InterruptedException {if (工作状态)
            wait();// 期待
        System.out.println("聊风月:" + 清倌);
        System.out.println("茶水费:" + price);
        System.out.println("" +"  "+"  "+"  "+"  "+"  "+"  "+"  "+"  "+"  "+ 清倌 +" 完事 "+" 筹备 ... ...");
        System.out.println("****************************************");
        工作状态 = true;
        notify();// 叫醒}

}

测试后果

聊风月:苍原野子
茶水费:500 日元
                    苍原野子完事筹备 ... ...
****************************************
聊风月:花田岗子
茶水费:800 日元
                    花田岗子完事筹备 ... ...
****************************************
聊风月:苍原野子
茶水费:500 日元
                    苍原野子完事筹备 ... ...
****************************************

...
  • 成果成果次要体现 wait、notify,这两个办法的应用。我置信你肯定能记住这个例子!

3. join

join 是两个线程的合并吗?不是的!

join 是让线程进入 wait,当线程执行结束后,会在 JVM 源码中找到,它执行结束后,其实执行 notify,也就是 期待 叫醒 操作。

源码:jdk8u_hotspot/blob/master/src/share/vm/runtime/thread.cpp

void JavaThread::exit(bool destroy_vm, ExitType exit_type) {// Notify waiters on thread object. This has to be done after exit() is called
    // on the thread (if the thread is the last thread in a daemon ThreadGroup the
    // group should have the destroyed bit set before waiters are notified).
    ensure_join(this);
}
static void ensure_join(JavaThread* thread) {
  // 叫醒
  java_lang_Thread::set_thread(threadObj(), NULL);
  lock.notify_all(thread);
}

好的,就是这里!lock.notify_all(thread),执行到这,就对上了。

案例代码

Thread thread = new Thread(() -> {System.out.println("thread before");
    try {Thread.sleep(3000);
    } catch (Exception e) {e.printStackTrace();
    }
    System.out.println("thread after");
});
thread.start();
System.out.println("main begin!");
thread.join();
System.out.println("main end!");

测试后果

main begin!thread before
thread after
main end!Process finished with exit code 0

首先 join() 是一个 synchronized 办法,外面调用了 wait(),这个过程的目标是让持有这个同步锁的线程进入期待,那么谁持有了这个同步锁呢?答案是主线程,因为主线程调用了 threadA.join()办法,相当于在 threadA.join()代码这块写了一个同步代码块,谁去执行了这段代码呢,是主线程,所以主线程被 wait()了。而后在子线程 threadA 执行结束之后,JVM 会调用 lock.notify_all(thread); 唤醒持有 threadA 这个对象锁的线程,也就是主线程,会继续执行。

  • 这部分验证的次要体现就是加了 thread.join() 后,会影响到输入后果。如果不加,main end! 会优先 thread after 提前打印进去。
  • join() 是一个 synchronized 办法,外面调用了 wait() 办法,让持有以后同步锁的线程进入期待状态,也就是主线程。当子线程执行结束后,咱们从源码中能够看到 JVM 调用了 lock.notify_all(thread) 所以唤醒了主线程继续执行。

六、总结

  • 线程状态和状态的转换也是面试中必问的问题,但除了面试是咱们本人在开发中,如果真的应用线程,是十分有必要理解线程状态是如何转换的。隐隐约约的应用,总会感觉放心,那么你是个好程序员!
  • 线程的一些深刻学习都是在调用本地办法,也就是须要理解到 JVM 层面,能力更加粗浅的见到 c ++ 代码是如何实现这部分逻辑的。
  • 在应用线程的时候肯定要让本人有一个相似多核的脑子,线程一起、生死由你!本章节就扯到这了,很多的常识都是为了整套内容体系的全面,为后续介绍其余常识打下根基。感激!

七、系列举荐

  • BATJTMD,大厂招聘,都招什么样 Java 程序员?
  • Thread.start(),它是怎么让线程启动的呢?
  • synchronized 解毒,分析源码深度剖析!
  • volatile 怎么实现的内存可见?没有 volatile 肯定不可见吗?
  • 鹿鼎记 · 韦小宝,丽春院、天地会、入皇宫等五个场景,搭配不同剧情解说多线程和锁,真香!

正文完
 0