1 概念

1.1 进程

进程是程序被操作系统内核加载到内存中后的一种内存中的数据结构，是系统进行资源分配和调度的基本单位。
思考：如何开启一个java进程？
每当执行 java命令（C:\Program Files\Java\jdk1.8.0_281\bin\java.exe）时，都会开启一个java进程。
java进程是否可以开启多个？
进程包括：

  • 进程的指令序列（代码段）
  • 进程号 pid
  • 进程的内存空间（堆空间，栈空间），
  • 系统资源（打开的文件描述符、网络IO Socket等）

image.png
什么是ava进程的堆空间，什么栈空间？

1.2 线程

  • 在一个进程内部，可以有多个线程（每个线程对应一组指令序列，可由cpu执行），由操作系统进行调度
  • 这些线程共享进程的堆内存，共享进程打开的系统资源
  • 每个线程有自己的栈空间

JVM-Architecture.png

1.3 主线程、子线程、守护(deamon)线程、非守护线程

  1. main线程结束后，java进程是否会结束？

取决与main方法中新开启的线程是不是 守护线程，如果不是守护线程，则java进程不会退出，如果是守护线程，则java程序会退出。

  1. // 如果不是守护线程，则java进程不会退出
  2. public class ThreadDemo01 {
  4.     public static void main(String[] args) {
  5.         System.out.println("main 方法执行开始");
  8.         final Thread thread = new Thread(new Runnable() {
  9.             @Override
  10.             public void run() {
  11.                 while (true){
  12.                     try {
  13.                         TimeUnit.SECONDS.sleep(1);
  14.                     } catch (InterruptedException e) {
  15.                         e.printStackTrace();
  16.                     }
  17.                     System.out.println(Thread.currentThread().getName());
  18.                 }
  19.             }
  20.         });
  21.         //开启新的线程
  22.         thread.start();
  24.         System.out.println("main 方法执行结束");
  25.     }
  26. }
  1. // 如果是守护线程，则java程序会退出
  2. public class ThreadDemo01 {
  4.     public static void main(String[] args) throws InterruptedException {
  5.         System.out.println("main 方法执行开始");
  8.         final Thread thread = new Thread(new Runnable() {
  9.             @Override
  10.             public void run() {
  11.                 while (true){
  12.                     try {
  13.                         TimeUnit.SECONDS.sleep(1);
  14.                     } catch (InterruptedException e) {
  15.                         e.printStackTrace();
  16.                     }
  17.                     System.out.println(Thread.currentThread().getName());
  18.                 }
  19.             }
  20.         });
  22.         // 设置线程为守护（后台）线程
  23.         thread.setDaemon(true);
  25.         //开启新的线程
  26.         thread.start();
  28.         TimeUnit.SECONDS.sleep(3);
  30.         System.out.println("main 方法执行结束");
  31.     }
  32. }
  1. java进程退出的条件？

java程序是否退出，取决于当前是否还有至少一个非守护线程存活。

1.4 main方法启动时，开启了几个线程？

  1.     private static void printAllThread() {
  2.         ThreadGroup group = Thread.currentThread().getThreadGroup();
  3.         ThreadGroup topGroup = group;
  4.         // 遍历线程组树，获取根线程组
  5.         while (group != null) {
  6.             topGroup = group;
  7.             group = group.getParent();
  8.         }
  9.         // 激活的线程数再加一倍，防止枚举时有可能刚好有动态线程生成
  10.         int slackSize = topGroup.activeCount() * 2;
  11.         Thread[] slackThreads = new Thread[slackSize];
  12.         // 获取根线程组下的所有线程，返回的actualSize便是最终的线程数
  13.         int actualSize = topGroup.enumerate(slackThreads);
  14.         Thread[] atualThreads = new Thread[actualSize];
  15.         // 复制slackThreads中有效的值到atualThreads
  16.         System.arraycopy(slackThreads, 0, atualThreads, 0, actualSize);
  17.         System.out.println("Threads size is " + atualThreads.length);
  18.         for (Thread thread : atualThreads) {
  19.             System.out.println("Thread name : " + thread.getName());
  20.         }
  21.     }
  23.     private static void dumpAllThreadsInfo() {
  24.         Set<Thread> threadSet = Thread.getAllStackTraces().keySet();
  25.         for (Thread thread : threadSet) {
  26.             System.out.println("dumpAllThreadsInfo thread.name=" + thread.getName()
  27.                     + ";group=" + thread.getThreadGroup()
  28.                     + ";isDaemon=" + thread.isDaemon()
  29.                     + ";priority=" + thread.getPriority());
  30.         }
  31.     }

1.5 串行、并行、并发

串行执行任务

  1. public class ThreadDemo02 {
  3.     public void task01() throws InterruptedException {
  4.         // 封装要执行的任务的代码逻辑
  5.         TimeUnit.SECONDS.sleep(1);
  7.         System.out.println("task01 is done");
  8.     }
  10.     public void task02() throws InterruptedException {
  11.         // 封装要执行的任务的代码逻辑
  12.         TimeUnit.SECONDS.sleep(2);
  14.         System.out.println("task02 is done");
  15.     }
  18.     public void task03() throws InterruptedException {
  19.         // 封装要执行的任务的代码逻辑
  20.         TimeUnit.SECONDS.sleep(3);
  22.         System.out.println("task03 is done");
  23.     }
  26.     // 如何执行这三个任务呢？
  27.     // 串行执行： 用一个线程把三个任务都执行完
  28.     public static void main(String[] args) throws InterruptedException {
  30.         new Thread(new Runnable() {
  31.             @Override
  32.             public void run() {
  33.                 final ThreadDemo02 threadDemo02 = new ThreadDemo02();
  34.                 try {
  35.                     threadDemo02.task01();
  36.                     threadDemo02.task02();
  37.                     threadDemo02.task03();
  38.                 } catch (InterruptedException e) {
  39.                     e.printStackTrace();
  40.                 }
  42.             }
  43.         }).start();
  45.         System.out.println("main finished");
  47.     }
  50. }

并行执行任务

  1. /**
  2.  * 串行、并行（并发）
  3.  */
  4. public class ThreadDemo03 {
  6.     public void task01() throws InterruptedException {
  7.         // 封装要执行的任务的代码逻辑
  8.         TimeUnit.SECONDS.sleep(1);
  10.         System.out.println("task01 is done");
  11.     }
  13.     public void task02() throws InterruptedException {
  14.         // 封装要执行的任务的代码逻辑
  15.         TimeUnit.SECONDS.sleep(2);
  17.         System.out.println("task02 is done");
  18.     }
  21.     public void task03() throws InterruptedException {
  22.         // 封装要执行的任务的代码逻辑
  23.         TimeUnit.SECONDS.sleep(3);
  25.         System.out.println("task03 is done");
  26.     }
  29.     // 如何执行这三个任务呢？
  30.     // 并行执行： 用三个线程分别去执行三个任务，每个线程执行一个任务
  31.     public static void main(String[] args) throws InterruptedException {
  33.         final ThreadDemo03 threadDemo03 = new ThreadDemo03();
  35.         // 创建三个线程执行任务
  36.         final Thread thread1 = new Thread(new Runnable() {
  37.             @Override
  38.             public void run() {
  39.                 try {
  40.                     final long start = System.currentTimeMillis();
  41.                     threadDemo03.task01();
  42.                     final long end = System.currentTimeMillis();
  43.                     System.out.println(Thread.currentThread().getName() + ":job finished,time used:" + (end - start));
  44.                 } catch (InterruptedException e) {
  45.                     e.printStackTrace();
  46.                 }
  48.             }
  49.         });
  51.         final Thread thread2 = new Thread(new Runnable() {
  52.             @Override
  53.             public void run() {
  54.                 try {
  55.                     final long start = System.currentTimeMillis();
  56.                     threadDemo03.task02();
  57.                     final long end = System.currentTimeMillis();
  58.                     System.out.println(Thread.currentThread().getName() + ":job finished,time used:" + (end - start));
  59.                 } catch (InterruptedException e) {
  60.                     e.printStackTrace();
  61.                 }
  63.             }
  64.         });
  66.         final Thread thread3 = new Thread(new Runnable() {
  67.             @Override
  68.             public void run() {
  69.                 try {
  70.                     final long start = System.currentTimeMillis();
  71.                     threadDemo03.task03();
  72.                     final long end = System.currentTimeMillis();
  73.                     System.out.println(Thread.currentThread().getName() + ":job finished,time used:" + (end - start));
  74.                 } catch (InterruptedException e) {
  75.                     e.printStackTrace();
  76.                 }
  78.             }
  79.         });
  82.         // 启动执行任务的线程
  83.         thread1.setName("thread1");
  84.         thread2.setName("thread2");
  85.         thread3.setName("thread3");
  87.         final long start = System.currentTimeMillis();
  89.         thread1.start();
  90.         thread2.start();
  91.         thread3.start();
  93.         // 让main线程等待其他三个线程都结束后再继续执行后面的代码
  94.         thread1.join(); // 等thread1结束
  95.         thread2.join();
  96.         thread3.join();
  98.         final long end = System.currentTimeMillis();
  100.         System.out.println("main finished,time used:"+(end-start));
  102.     }
  105. }

image.png

2 创建线程

2.1 直接使用Thread类的构造函数

  1.         final Thread t1 = new Thread(new Runnable() {
  2.             @Override
  3.             public void run() {
  4.                 try {
  5.                     threadDemo02.task1();
  6.                 } catch (InterruptedException e) {
  7.                     e.printStackTrace();
  8.                 }
  9.             }
  10.         });

2.2 继承Thread类覆盖run方法

  1. /**
  2.  * 创建线程的方式
  3.  */
  4. public class ThreadDemo04 extends Thread{
  6.     // 覆盖run 方法
  7.     @Override
  8.     public void run() {
  9.         System.out.println(Thread.currentThread().getName()+ ": ThreadDemo04 started....");
  10.     }
  12.     public static void main(String[] args) {
  14.         final ThreadDemo04 threadDemo04 = new ThreadDemo04();
  15.         threadDemo04.start();
  16.         System.out.println(Thread.currentThread().getName()+ " main finished");
  18.     }
  20. }

3 启动线程

3.1 启动线程的是run方法还是start方法？

  1. public class ThreadDemo04 extends Thread{
  3.     // 覆盖run 方法
  4.     @Override
  5.     public void run() {
  6.         System.out.println(Thread.currentThread().getName()+ ": ThreadDemo04 started....");
  7.     }
  9.     public static void main(String[] args) {
  11.         final ThreadDemo04 threadDemo04 = new ThreadDemo04();
  12. //        threadDemo04.start();
  13.         // 在当前线程中进行的一个对象的实例方法的调用而已，run就是一个普通的实例方法
  14.         // 属于当前线程内的串行方法调用
  15. //        threadDemo04.run();
  16.         // start方法，内部有特殊的逻辑，会让jvm跟底层操作系统交互，创建出一个新的线程
  17.         threadDemo04.start();
  18.         System.out.println(Thread.currentThread().getName()+ " main finished");
  20.     }
  22. }
  • start方法是启动线程的方法
  • run方法定义了线程启动之后要执行的业务逻辑
  • 如果在main线程中直接调用了线程对象的run方法，则相当于串行模式调用所有线程的run方法了，不会开启新的线程。

    3.2 java真的能启动一个线程吗？

    实际上线程的启动是由操作系统完成的，java语言中的Thread对象的start方法，最后会调用一个navtive方法start0，该方法会借由jvm进行底层的创建线程的系统调用，最后由操作系统内核创建出一个新的线程，并且把新线程的方法入口，设置为线程对象的run方法。
    1. private native void start0();

4 线程的调度

4.1 线程的调度由操作系统决定

4.2 多线程程序可能出现不同的执行结果

在没有采用任何同步措施的情况下，多线程程序的运行结果可能不同。

  1. package com.qf.sy2103.thread01;
  3. public class ThreadDemo04 {
  5.     public static void main(String[] args) {
  7.         final Thread t1 = new Thread(new Runnable() {
  8.             @Override
  9.             public void run() {
  10.                 System.out.println("t1 started ...");
  11.             }
  12.         });
  14.         final Thread t2 = new Thread(new Runnable() {
  15.             @Override
  16.             public void run() {
  17.                 System.out.println("t2 started ...");
  18.             }
  19.         });
  21.         final Thread t3 = new Thread(new Runnable() {
  22.             @Override
  23.             public void run() {
  24.                 System.out.println("t3 started ...");
  25.             }
  26.         });
  28.         t1.start();
  29.         t2.start();
  30.         t3.start();
  32.     }
  35. }

image.png

5 Thread对象API

  • currentThread
    • 获取到执行当前方法的Thread对象
    • 是一个native方法
  • isAlive ```java package com.qf.sy2103.thread01;

import java.util.concurrent.TimeUnit;

public class ThreadApiDemo {

  1. public static void main(String[] args) throws InterruptedException {
  3.     final Thread t1 = new Thread(new Runnable() {
  4.         @Override
  5.         public void run() {
  6.             System.out.println(Thread.currentThread().isAlive());
  7.             System.out.println("t1 started ...");
  8.         }
  9.     });
  11.     System.out.println(t1.isAlive());
  12.     t1.start();
  13.     TimeUnit.SECONDS.sleep(1);
  14.     System.out.println(t1.isAlive());
  16. }

}

  2. - sleep
  3.    - 让执行当前方法的线程，进入休眠状态，休眠方法参数指定的毫秒数。
  4. - getid
  5. ```java
  6.         System.out.println("main 线程的id为:"+Thread.currentThread().getId());
  7.         System.out.println("t1 线程的id为:"+t1.getId());
  • interrupt

中断失败的例子如下

  1. public class ThreadDemo08 {
  3.     public static void main(String[] args) throws InterruptedException {
  5.         final Thread thread1 = new Thread(new Runnable() {
  6.             @Override
  7.             public void run() {
  8.                 while (true){
  9.                     try {
  10.                         TimeUnit.SECONDS.sleep(1);
  11.                     } catch (InterruptedException e) {
  12.                         e.printStackTrace();
  13.                     }
  14.                     System.out.println(Thread.currentThread().getName()+"is running....");
  15.                 }
  16.             }
  17.         });
  19.         thread1.setName("thread1");
  20.         thread1.start();
  22.         TimeUnit.SECONDS.sleep(2);
  23.         // 中断 thread1 
  24.         thread1.interrupt();
  28.     }
  30. }
  1. public class ThreadInterruptDemo {
  3.     public static void main(String[] args) throws InterruptedException {
  5.         final Thread t1 = new Thread(new Runnable() {
  6.             @Override
  7.             public void run() {
  8.                 while (true){
  9.                     System.out.println("t1 is busy ...");
  10.                     // 监听线程自身是否被中断
  11.                     if (Thread.currentThread().isInterrupted()) {
  12.                         return;
  13.                     }
  14.                 }
  15.             }
  16.         });
  18.         t1.start();
  20.         TimeUnit.SECONDS.sleep(1);
  22.         t1.interrupt();  //  打断t1线程
  24.     }
  27. }
  1. // 打断 sleep中的线程 会抛出异常 InterruptedException
  2. public class ThreadInterruptDemo {
  4.     public static void main(String[] args) throws InterruptedException {
  6.         final Thread t1 = new Thread(new Runnable() {
  7.             @Override
  8.             public void run() {
  9.                 while (true){
  10.                     System.out.println("t1 is busy ...");
  11.                     try {
  12.                         Thread.sleep(1000000);
  13.                     } catch (InterruptedException e) {
  14.                         e.printStackTrace();
  15.                     }
  16.                 }
  17.             }
  18.         });
  20.         t1.start();
  22.         TimeUnit.SECONDS.sleep(1);
  24.         t1.interrupt();  //  打断t1线程
  26.     }
  29. }
  • setDeamon

设置线程是否为守护线程，默认是false 。java应用中必须要有至少一个非守护线程存活，程序才不会退出。

  • join
    • 在某个线程对象上调用join方法，会把执行当前方法的线程进行阻塞，等到目标线程执行完毕后才可以继续运行。
    • 注意：调用join方法时，存在两个线程，一个是发起调用的线程，例如main线程，另外一个是执行join方法的线程对象所代表的线程A。执行的效果是让main线程进入等待，等待线程A执行完毕。 ```java package com.qf.sy2103.thread01;

import java.util.concurrent.TimeUnit;

public class ThreadJoinDemo {

  1. public static void main(String[] args) throws InterruptedException {
  3.     final Thread t1 = new Thread(new Runnable() {
  4.         @Override
  5.         public void run() {
  6.             try {
  7.                 TimeUnit.SECONDS.sleep(1);
  8.             } catch (InterruptedException e) {
  9.                 e.printStackTrace();
  10.             }
  11.         }
  12.     });
  14.     final Thread t2 = new Thread(new Runnable() {
  15.         @Override
  16.         public void run() {
  17.             try {
  18.                 TimeUnit.SECONDS.sleep(2);
  19.             } catch (InterruptedException e) {
  20.                 e.printStackTrace();
  21.             }
  22.         }
  23.     });
  25.     final long start = System.currentTimeMillis();
  27.     t1.start();
  28.     t2.start();
  30.     t1.join();  // 等待，直到 t1线程 运行结束
  31.     t2.join();
  34.     final long end = System.currentTimeMillis();
  35.     System.out.println(end - start);
  37. }

}

  1. 思考题：有三个线程A、B和C，希望以如下顺序执行，A先执行，A执行完之后B执行，B执行完之后C执行？
  2. ```java
  3. /**
  4.  * 思考题：有三个线程A、B和C，希望以如下顺序执行，A先执行，A执行完之后B执行，B执行完之后C执行？
  5.  */
  6. public class ThreadDemo09 {
  8.     public static void main(String[] args) throws InterruptedException {
  10.         final Thread threadA = new Thread(new Runnable() {
  11.             @Override
  12.             public void run() {
  13.                 System.out.println(Thread.currentThread().getName()+": 完成了任务A");
  14.             }
  15.         });
  17.         final Thread threadB = new Thread(new Runnable() {
  18.             @Override
  19.             public void run() {
  20.                 try {
  21.                     threadA.join(); // 等待 A线程执行完成
  22.                 } catch (InterruptedException e) {
  23.                     e.printStackTrace();
  24.                 }
  25.                 System.out.println(Thread.currentThread().getName()+": 完成了任务B");
  26.             }
  27.         });
  29.         final Thread threadC = new Thread(new Runnable() {
  30.             @Override
  31.             public void run() {
  32.                 try {
  33.                     threadB.join();
  34.                 } catch (InterruptedException e) {
  35.                     e.printStackTrace();
  36.                 }
  37.                 System.out.println(Thread.currentThread().getName()+": 完成了任务C");
  38.             }
  39.         });
  41.         threadA.setName("A");
  42.         threadB.setName("B");
  43.         threadC.setName("C");
  45.         // 启动三个线程
  46.         threadA.start();
  47.         threadB.start();
  48.         threadC.start();
  51.     }
  53. }

6 线程的生命周期

6.1 Thread类中定义的线程状态

  1. public enum State {
  2.         /**
  3.          * Thread state for a thread which has not yet started.
  4.          */
  5.         NEW,
  7.         /**
  8.          * Thread state for a runnable thread.  A thread in the runnable
  9.          * state is executing in the Java virtual machine but it may
  10.          * be waiting for other resources from the operating system
  11.          * such as processor.
  12.          */
  13.         RUNNABLE,
  15.         /**
  16.          * Thread state for a thread blocked waiting for a monitor lock.
  17.          * A thread in the blocked state is waiting for a monitor lock
  18.          * to enter a synchronized block/method or
  19.          * reenter a synchronized block/method after calling
  20.          * {@link Object#wait() Object.wait}.
  21.          */
  22.         BLOCKED,
  24.         /**
  25.          * Thread state for a waiting thread.
  26.          * A thread is in the waiting state due to calling one of the
  27.          * following methods:
  28.          * <ul>
  29.          *   <li>{@link Object#wait() Object.wait} with no timeout</li>
  30.          *   <li>{@link #join() Thread.join} with no timeout</li>
  31.          *   <li>{@link LockSupport#park() LockSupport.park}</li>
  32.          * </ul>
  33.          *
  34.          * <p>A thread in the waiting state is waiting for another thread to
  35.          * perform a particular action.
  36.          *
  37.          * For example, a thread that has called <tt>Object.wait()</tt>
  38.          * on an object is waiting for another thread to call
  39.          * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
  40.          * that object. A thread that has called <tt>Thread.join()</tt>
  41.          * is waiting for a specified thread to terminate.
  42.          */
  43.         WAITING,
  45.         /**
  46.          * Thread state for a waiting thread with a specified waiting time.
  47.          * A thread is in the timed waiting state due to calling one of
  48.          * the following methods with a specified positive waiting time:
  49.          * <ul>
  50.          *   <li>{@link #sleep Thread.sleep}</li>
  51.          *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
  52.          *   <li>{@link #join(long) Thread.join} with timeout</li>
  53.          *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
  54.          *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
  55.          * </ul>
  56.          */
  57.         TIMED_WAITING,
  59.         /**
  60.          * Thread state for a terminated thread.
  61.          * The thread has completed execution.
  62.          */
  63.         TERMINATED;
  64.     }

6.2 生命周期状态转换

线程基础 - 图5

6.3 案例 利用jconsole观察线程状态

  1. // 线程的NEW  RUNNABLE TERMINATED  
  2. public class ThreadStateDemo {
  4.     public static void main(String[] args) throws InterruptedException {
  6.         final Thread t1 = new Thread(new Runnable() {
  7.             @Override
  8.             public void run() {
  9.                 int a = 0;
  10.                 for (int i = 0; i < 100000000 ; i++) {
  11.                     a++;
  12.                 }
  13.                 System.out.println(a);
  14.             }
  15.         });
  17.         System.out.println("线程对象刚创建好："+t1.getState());
  19.         t1.start();
  21.         Thread.sleep(1);
  23.         System.out.println("线程对象已经start："+t1.getState());
  25.         Thread.sleep(2000);
  27.         System.out.println("线程已经运行完成："+t1.getState());
  29.     }
  31. }
  1. /**
  2.  * 如果线程执行了 休眠方法 ， Thread.sleep   TimeUnit.SECONDS.sleep
  3.  * 则线程的状态是 TIMED_WAITING
  4.  */
  5. public class ThreadStateDemo3 {
  7.     public static void main(String[] args) throws InterruptedException {
  9.         final Thread t1 = new Thread(new Runnable() {
  10.             @Override
  11.             public void run() {
  12.                 try {
  13.                     TimeUnit.SECONDS.sleep(10000);
  14.                 } catch (InterruptedException e) {
  15.                     e.printStackTrace();
  16.                 }
  17.             }
  18.         });
  20.         t1.start();
  22.         TimeUnit.SECONDS.sleep(2);
  24.         System.out.println(t1.getState());
  26.     }
  28. }
  1. // 观察主线程和子线程的状态变化 
  2. public class ThreadStateDemo2 {
  3.     public static void main(String[] args) throws InterruptedException, IOException {
  5.         Thread mainThread = Thread.currentThread();
  6.         Object lock = new Object();
  7.         Thread subthread = new Thread(new Runnable() {
  8.             @Override
  9.             public void run() {
  10.                 try {
  11.                     Thread.sleep(1000);
  12.                     synchronized (lock) {
  13.                         System.out.println("mainThread state is "+mainThread.getState());
  14.                         lock.notify();
  15.                     }
  16.                 } catch (InterruptedException e) {
  17.                     e.printStackTrace();
  18.                 }
  19.             }
  20.         });
  21.         subthread.start();
  22.         synchronized (lock) {
  23.             System.in.read();
  24.             System.out.println("subthread state is "+subthread.getState());
  25.             lock.wait();
  26.         }
  27.     }
  28. }

观察主线程由waitting状态转换为Block状态

  1. public class ThreadStateDemo2 {
  2.     public static void main(String[] args) throws InterruptedException, IOException {
  4.         Thread mainThread = Thread.currentThread();
  5.         Object lock = new Object();
  6.         Thread t1 = new Thread(new Runnable() {
  7.             @Override
  8.             public void run() {
  9.                 try {
  10.                     Thread.sleep(1000);
  11.                     synchronized (lock) {
  12.                         System.out.println("t1 mainThread state is "+mainThread.getState());
  13.                         lock.notify();
  14.                     }
  15.                 } catch (InterruptedException e) {
  16.                     e.printStackTrace();
  17.                 }
  18.             }
  19.         });
  21.         Thread t2 = new Thread(new Runnable() {
  22.             @Override
  23.             public void run() {
  24.                 try {
  25.                     Thread.sleep(1000);
  26.                     synchronized (lock) {
  27.                         System.out.println("t2 mainThread state is "+mainThread.getState());
  28.                         lock.notify();
  29.                     }
  30.                 } catch (InterruptedException e) {
  31.                     e.printStackTrace();
  32.                 }
  33.             }
  34.         });
  37.         t1.start();
  38.         t2.start();
  40.         synchronized (lock) {
  41.             System.in.read();
  42.             System.out.println("t1 state is "+t1.getState());
  43.             System.out.println("t2 state is "+t2.getState());
  44.             lock.wait();
  45.         }
  46.     }
  47. }

观察主线程由Timed-waitting状态转换为Block状态

  1. public class ThreadStateDemo3 {
  2.     public static void main(String[] args) throws InterruptedException, IOException {
  4.         Thread mainThread = Thread.currentThread();
  5.         Object lock = new Object();
  6.         Thread t1 = new Thread(new Runnable() {
  7.             @Override
  8.             public void run() {
  9.                 try {
  10.                     Thread.sleep(1000);
  11.                     synchronized (lock) {
  12.                         System.out.println("t1 mainThread state is "+mainThread.getState());
  13.                         Thread.sleep(3000);
  14.                         System.out.println("t1 mainThread state is "+mainThread.getState());
  15.                         lock.notify();
  16.                     }
  17.                 } catch (InterruptedException e) {
  18.                     e.printStackTrace();
  19.                 }
  20.             }
  21.         });
  23.         t1.start();
  24.         synchronized (lock) {
  25.             System.in.read();
  26.             System.out.println("t1 state is "+t1.getState());
  27.             // 主线程等待2s后醒来，继续争抢锁
  28.             // 注意：不是wait达到超时时间后就无条件继续向下执行代码！而是要继续去枪锁！
  29.             lock.wait(2000);
  30.             // 如果醒来后争抢锁失败，则线程直接进入blcok状态
  31.             // 当持有锁的线程释放锁后，主线程会继续去争抢锁，如果抢到，就可以继续执行
  32.             System.out.println("main finished ");
  33.         }
  34.     }
  35. }