请选择 进入手机版 | 继续访问电脑版
零一零零 门户 IT技术 Java并发 查看内容

Java并发编程之线程状态

2020-7-3 11:21| 发布者: x0100| 查看: 803| 评论: 0

摘要: 1. 创建启动线程 两种方法 创建和启动线程两种方法:继承 Thread 类、实现 Runable 接口。 方法一:继承 Thread public class Test { public static void main(String args) { MyThread thread = new MyThread(); th ...


1. 创建启动线程

两种方法

创建和启动线程两种方法:继承 Thread 类、实现 Runable 接口。

方法一:继承 Thread

  1. public class Test {
  2. public static void main(String[] args) {
  3. MyThread thread = new MyThread();
  4. thread.start();
  5. }
  6. }
  7. class MyThread extends Thread {
  8. @Override
  9. public void run() {
  10. System.out.println("创建线程");
  11. }
  12. }

方法二:实现 Runable

  1. public class Test {
  2. public static void main(String[] args) {
  3. Thread thread = new Thread(new MyRunnable());
  4. thread.start();
  5. }
  6. }
  7. class MyRunnable implements Runnable{
  8. @Override
  9. public void run() {
  10. System.out.println("创建线程");
  11. }
  12. }

创建线程实现

通过查看 Thread 类代码,不管是继承 Thread 类创建线程还是实现 Runable 创建线程,都是调用 Thread 类的 init 方法,来看下 init 方法:

  1. private void init(ThreadGroup g, Runnable target, String name,
  2. long stackSize, AccessControlContext acc,
  3. boolean inheritThreadLocals) {
  4. if (name == null) {
  5. throw new NullPointerException("name cannot be null");
  6. }
  7. this.name = name;
  8. // 当前线程就是此新线程的父线程
  9. Thread parent = currentThread();
  10. SecurityManager security = System.getSecurityManager();
  11. if (g == null) {
  12. if (security != null) {
  13. g = security.getThreadGroup();
  14. }
  15. if (g == null) {
  16. g = parent.getThreadGroup();
  17. }
  18. }
  19. g.checkAccess();
  20. if (security != null) {
  21. if (isCCLOverridden(getClass())) {
  22. security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
  23. }
  24. }
  25. g.addUnstarted();
  26. // 新线程继承了parent线程的group、是否为Daemon、优先级priority、加载资源的contextClassLoader、可继承的ThreadLocal。
  27. this.group = g;
  28. this.daemon = parent.isDaemon();
  29. this.priority = parent.getPriority();
  30. if (security == null || isCCLOverridden(parent.getClass()))
  31. this.contextClassLoader = parent.getContextClassLoader();
  32. else
  33. this.contextClassLoader = parent.contextClassLoader;
  34. this.inheritedAccessControlContext = acc != null ? acc
  35. : AccessController.getContext();
  36. this.target = target;
  37. setPriority(priority);
  38. if (inheritThreadLocals && parent.inheritableThreadLocals != null)
  39. this.inheritableThreadLocals = ThreadLocal
  40. .createInheritedMap(parent.inheritableThreadLocals);
  41. this.stackSize = stackSize;
  42. // parent线程为新线程分配一个唯一的ID
  43. tid = nextThreadID();
  44. }

通过 init 方法可以看出:

  1. 新构造的线程对象是由其 parent 线程来进行空间分配的。

  2. 新线程继承了 parent 线程的 group、是否为 Daemon、优先级 priority、加载资源的 contextClassLoader、可继承的 ThreadLocal。

  3. parent 线程会分配一个唯一的 ID 来标识这个 child 新线程。

启动线程

start()方法启动线程。

线程 start()方法的含义是:当前线程(即 parent 线程)同步告知 Java 虚拟机,只要线程规划器空闲,应立即启动调用 start()方法的线程。

注意:

  1. 启动线程调用 start()方法,而不是 run()。

  2. 启动一个线程前,最好为这个线程设置线程名称,因为这样在使用 jstack 分析程序或者进行问题排查时,就会给开发人员提供一些提示,自定义的线程最好能够起个名字。

2. 线程状态

状态

1. 新建状态(NEW)

当程序使用 new 关键字创建了一个线程之后,线程就处于新建状态,此时的线程情况如下:

  1. 此时 JVM 为其分配内存,并初始化其成员变量的值;

  2. 此时线程对象没有表现出任何线程的动态特征,程序也不会执行线程的线程执行体;

2. 就绪状态(RUNNABLE)

当线程对象调用了 start()方法之后,线程处于就绪状态。此时的线程情况如下:

  1. 此时 JVM 会为其创建方法调用栈和程序计数器;

  2. 线程并没有开始运行,而是等待系统为其分配 CPU 时间片;

3. 运行状态(RUNNING)

当线程获得了 CPU 时间片,CPU 调度处于就绪状态的线程并执行 run()方法的线程执行体,则该线程处于运行状态。

  1. 如果计算机只有一个CPU,那么在任何时刻只有一个线程处于运行状态;
  2. 如果在一个多处理器的机器上,将会有多个线程并行执行,处于运行状态;
  3. 当线程数大于处理器数时,依然会存在多个线程在同一个CPU上轮换的现象;

对于采用抢占式策略的系统而言,系统会给每个可执行的线程分配一个时间片来处理任务;当该时间片用完后,系统就会剥夺该线程所占用的资源,让其他线程获得执行的机会。此时线程就会又从运行状态变为就绪状态,重新等待系统分配资源。

4. 阻塞状态(BLOCKED)

处于运行状态的线程在某些情况下,让出 CPU 并暂时停止自己的运行,进入阻塞状态。如:线程阻塞于 synchronized 锁。

5. 等待状态(WAITING)

线程处于无限制等待状态,等待一个特殊的事件来重新唤醒,唤醒线程之后进入就绪状态,如:

  1. 通过wait()方法进行等待的线程等待一个notify()或者notifyAll()方法;
  2. 通过join()方法进行等待的线程等待目标线程运行结束而唤醒;

阻塞在 java.concurrent 包中 Lock 接口的线程状态不是 BLOCK 状态,而是 WAITING 等待状态,因为 java.concurrent 包中 Lock 接口对于阻塞的实现均使用了 LockSupport 类中的相关方法。

6. 超时等待状态(TIMED_WAITING)

线程进入了一个时限等待状态,如:sleep(3000),等待 3 秒后线程重新进入就绪状态。

7. 死亡状态(DEAD)

线程会以如下 3 种方式结束,结束后就处于死亡状态:

① run()或 call()方法执行完成,线程正常结束;

② 线程抛出一个未捕获的 Exception 或 Error;

③ 直接调用该线程 stop()方法来结束该线程—该方法容易导致死锁,通常不推荐使用;

状态转换

线程状态转换——《Java并发编程艺术》

查看线程状态

Java 服务器问题排查中,经常需要查看线程状态来定位问题。

查看如下示例代码的线程运行状态:

  1. public class ThreadState {
  2. public static void main(String[] args) {
  3. new Thread(new RunThread(), "RunThread").start();// 一直处于RUNNABLE线程
  4. new Thread(new TimeWaiting(), "TimeWaitingThread").start();// TIMED_WAITING线程
  5. new Thread(new Waiting(), "WaitingThread").start();// WAITING线程
  6. new Thread(new Blocked(), "BlockedThread-1").start();// 获取锁之后TIMED_WAITING
  7. new Thread(new Blocked(), "BlockedThread-2").start();// 获取不到锁,被阻塞BLOCKED
  8. }
  9. // 该线程一直运行
  10. static class RunThread implements Runnable {
  11. @Override
  12. public void run() {
  13. while (true) {
  14. System.out.println(1);
  15. }
  16. }
  17. }
  18. // 该线程不断地进行睡眠 TIMED_WAITING
  19. static class TimeWaiting implements Runnable {
  20. @Override
  21. public void run() {
  22. while (true) {
  23. try {
  24. Thread.sleep(1000);
  25. } catch (InterruptedException e) {
  26. e.printStackTrace();
  27. }
  28. }
  29. }
  30. }
  31. // 该线程在Waiting.class实例上等待 WAITING
  32. static class Waiting implements Runnable {
  33. @Override
  34. public void run() {
  35. while (true) {
  36. synchronized (Waiting.class) {
  37. try {
  38. Waiting.class.wait();
  39. } catch (InterruptedException e) {
  40. e.printStackTrace();
  41. }
  42. }
  43. }
  44. }
  45. }
  46. // 该线程在Blocked.class实例上加锁后,不会释放该锁
  47. static class Blocked implements Runnable {
  48. public void run() {
  49. synchronized (Blocked.class) {
  50. while (true) {
  51. try {
  52. Thread.sleep(1000);
  53. } catch (InterruptedException e) {
  54. e.printStackTrace();
  55. }
  56. }
  57. }
  58. }
  59. }
  60. }
  1. Export 导出 jar 包 ThreadState.jar

  2. Linux 环境或者 windows 的命令界面,运行 ThreadState.jar。

  3. 执行命令

    java -cp ThreadState.jar test.ThreadState

  4. 到 java 安装目录(我的目录是:/usr/java/jdk1.8.0_161/bin)下,执行 ./jps ,显示如下:

    5435 ThreadState

5435 就是 ThreadState.jar 程序的进程 id

  1. 执行命令 ./jstack 5435 ,查看线程状态

  1. // 名为"BlockedThread-2" 的线程状态:TIMED_WAITING
  2. "BlockedThread-2" #13 prio=5 os_prio=0 tid=0x00007fa8f0157800 nid=0x154f waiting on condition [0x00007fa8c962e000]
  3. java.lang.Thread.State: TIMED_WAITING (sleeping)
  4. at java.lang.Thread.sleep(Native Method)
  5. at test.ThreadState$Blocked.run(ThreadState.java:61)
  6. - locked <0x00000000d9408370> (a java.lang.Class for test.ThreadState$Blocked)
  7. at java.lang.Thread.run(Thread.java:748)
  8. // 名为"BlockedThread-1" 的线程状态:BLOCKED
  9. "BlockedThread-1" #12 prio=5 os_prio=0 tid=0x00007fa8f0156000 nid=0x154e waiting for monitor entry [0x00007fa8c972f000]
  10. java.lang.Thread.State: BLOCKED (on object monitor)
  11. at test.ThreadState$Blocked.run(ThreadState.java:61)
  12. - waiting to lock <0x00000000d9408370> (a java.lang.Class for test.ThreadState$Blocked)
  13. at java.lang.Thread.run(Thread.java:748)
  14. // 名为"WaitingThread" 的线程状态:WAITING
  15. "WaitingThread" #11 prio=5 os_prio=0 tid=0x00007fa8f0154000 nid=0x154d in Object.wait() [0x00007fa8c9830000]
  16. java.lang.Thread.State: WAITING (on object monitor)
  17. at java.lang.Object.wait(Native Method)
  18. - waiting on <0x00000000d9408560> (a java.lang.Class for test.ThreadState$Waiting)
  19. at java.lang.Object.wait(Object.java:502)
  20. at test.ThreadState$Waiting.run(ThreadState.java:46)
  21. - locked <0x00000000d9408560> (a java.lang.Class for test.ThreadState$Waiting)
  22. at java.lang.Thread.run(Thread.java:748)
  23. // 名为"TimeWaitingThread" 的线程状态:TIMED_WAITING
  24. "TimeWaitingThread" #10 prio=5 os_prio=0 tid=0x00007fa8f0152800 nid=0x154c waiting on condition [0x00007fa8c9931000]
  25. java.lang.Thread.State: TIMED_WAITING (sleeping)
  26. at java.lang.Thread.sleep(Native Method)
  27. at test.ThreadState$TimeWaiting.run(ThreadState.java:31)
  28. at java.lang.Thread.run(Thread.java:748)
  29. // 名为"RunThread" 的线程状态:RUNNABLE
  30. "RunThread" #9 prio=5 os_prio=0 tid=0x00007fa8f0150800 nid=0x154b runnable [0x00007fa8c9a32000]
  31. java.lang.Thread.State: RUNNABLE
  32. at java.io.FileOutputStream.writeBytes(Native Method)
  33. at java.io.FileOutputStream.write(FileOutputStream.java:326)
  34. at java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)
  35. at java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)
  36. - locked <0x00000000d942e020> (a java.io.BufferedOutputStream)
  37. at java.io.PrintStream.write(PrintStream.java:482)
  38. - locked <0x00000000d9404b30> (a java.io.PrintStream)
  39. at sun.nio.cs.StreamEncoder.writeBytes(StreamEncoder.java:221)
  40. at sun.nio.cs.StreamEncoder.implFlushBuffer(StreamEncoder.java:291)
  41. at sun.nio.cs.StreamEncoder.flushBuffer(StreamEncoder.java:104)
  42. - locked <0x00000000d9404ae8> (a java.io.OutputStreamWriter)
  43. at java.io.OutputStreamWriter.flushBuffer(OutputStreamWriter.java:185)
  44. at java.io.PrintStream.write(PrintStream.java:527)
  45. - eliminated <0x00000000d9404b30> (a java.io.PrintStream)
  46. at java.io.PrintStream.print(PrintStream.java:597)
  47. at java.io.PrintStream.println(PrintStream.java:736)
  48. - locked <0x00000000d9404b30> (a java.io.PrintStream)
  49. at test.ThreadState$RunThread.run(ThreadState.java:20)
  50. at java.lang.Thread.run(Thread.java:748)

总结

Java 中创建线程两种方法:继承 Thread 和实现 Runable。线程的启动调用 start 方法,线程执行 run 方法。

新构造的线程对象是由其 parent 线程来进行空间分配的和线程 id 的,新线程继承 parent 线程的 group、是否为 Daemon、优先级 priority 等属性。

线程的状态:NEW、RUNNABLE、RUNNING、BLOCKED、WAITING、TIMED_WAITING、DEAD。

Java 服务器问题排查过程中,常用的 jstack 命令查看线程状态。


鲜花

握手

雷人

路过

鸡蛋

最新评论


QQ|Archiver|手机版|小黑屋| 零一零零 ( 京ICP备20003964号 ) |网站地图

GMT+8, 2020-10-31 17:48 , Processed in 0.038402 second(s), 17 queries .

Powered by Discuz! X3.4

© 2001-2013 Comsenz Inc.

返回顶部