Java中Thread类详解及常用的方法

一、Thread 的常见构造方法

关于前两种方法，在之前的线程创建介绍中有使用到

线程创建根本上来讲有两种创建方法：

创建一个继承自 Thread 类的子类，重写 Thread 中的 run 方法，调用 start 方法创建一个实现 Runnable 接口的类，重写 Thread 中的 run 方法。创建 Thread 实例，将自己写的实现 Runnable 接口的类的实例设置进去，调用 start 方法

构造方法三和四不过是在前面两种构造方法的基础上多添加了一个给线程对象命名的参数，方便程序员进行调试。

代码（以构造方法四为例）：

public class func7 {
   public static void main(String[] args) {
       Thread thread = new Thread(() ->{
           while (true) {
               System.out.println("This is my Thread");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       },"myThread");
       //此处用 lambda 表达式代替 Runnable 实例，更加简洁，添加了一个参数指定thread线程的名字
       thread.start();
       while (true) {
           System.out.println("my main");
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }
}

程序员可以通过 JDK 自带的jconsole工具来直观查看这里创建的线程

步骤一：

运行程序后，找到自己的 jdk 路径 -> bin ->jconsole.exe

步骤二：双击该 exe 文件。选择本地进程，这里罗列着 Java 进程。可以看见我们的程序 func7 ，点击它。在菜单栏选择线程一栏

步骤三：查看线程信息

左侧可以选择需要被查看的线程，可以看见主线程 main和新创建的线程 myThread ，如果没有重命名操作的话新创建的线程名就会叫 Thread-0，Thread-1 这样的名字，不方便查看。

右侧显示了该线程的被读取的那一瞬间的状态，堆栈跟踪显示的是代码具体执行的位置

二、Thread 的常见属性

解释：

1. 线程的唯一标识就是线程 Id

2. 名称在上面的案例中有所体现，为调试提供了便利

3. 状态表示线程当前所处的情况，上面的案例中，线程因为调用了 sleep 方法就进入了阻塞状态

4. 优先级表示该线程被调度到的难易度，高的更容易被调度到

5. 判断是否为后台线程。如果是后台线程，那么该后台线程不会影响 java 进程的结束；如果是非后台线程，JVM 就会等到所有的非后台线程执行完毕，才会结束运行，因此会影响到总进程的结束

6. 是否存活是来判断线程是否还存在的方法。当创建出 Thread 实例对象时，线程未必就创建了，需要调用 start 方法，才是真正的创建了线程。当线程中的 run 方法执行完毕，线程结束被销毁了，创建出的实例对象还没被销毁回收。所以说，创建出的实例对象和线程的生命周期是不完全相同的

在线程的状态中，除了NEW 和 TERMINATED 以外的状态都是活着的

代码：

public class func8 {
   public static void main(String[] args) {
       Thread t = new Thread(()->{
           for (int i = 0;i < 5;i ++) {
               System.out.println("新线程~");
               try {
                   Thread.sleep(2000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       },"newThread");
       System.out.println("新线程状态：" +t.getState());
       //创建了对象，没创建线程
       t.start();
       System.out.println("新线程状态：" +t.getState());
       //创建了线程
       System.out.println("新线程Id："+t.getId());
       System.out.println("新线程名称："+t.getName());
       System.out.println("新线程是否为后台线程：" + t.isDaemon());
       System.out.println("新线程是否被中断：" + t.isInterrupted());
       System.out.println("新线程优先级：" + t.getPriority());
       System.out.println("主线程名称："+Thread.currentThread().getName());
       while (t.isAlive()) {} //当t线程还存在时，主线程就搁这儿循环着，直到线程结束
       System.out.println("新线程状态：" +t.getState());//线程结束
   }
}

结果：

三、创建线程

创建 Thread 类的对象不意味着线程被创建出，start() 方法才是真正的在操作系统内部创建一个新的线程，通过重写 run 方法来描述需要执行的任务，从而真正实现了多线程运行。

四、中断线程

方法一：手动设置标志位，作为中断线程的条件

public class func9 {
   private static Boolean flag = false;//手动设置的标志位 flag
   public static void main(String[] args) {
       Thread t = new Thread(() -> {
           while (!flag) {
               //flag 为真时停止循环
               System.out.println("myThread");
               try {
                   Thread.sleep(1000);//打印一次，阻塞一秒
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       });
       t.start();//创建了线程 t
       try {
           Thread.sleep(3000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       flag = true;
       //等3秒后，在主线程中将 flag 的值改成 true，从而使线程t循环条件不成立
   }
}

方法二：使用 Thread 实例中的标志位

public class func10 {
   public static void main(String[] args) {
       Thread t = new Thread() {
           @Override
           public void run() {
               //通过 isInerrupted()判断标志位是否为true，为true说明线程要退出
               while (!this.isInterrupted()) {
                  System.out.println("my Thread");
                  try {
                      Thread.sleep(1000);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                      //System.out.println("完善工作");
                      //break;
                  }
              }
           }
       };
       t.start();//创建新的线程
       try {
           Thread.sleep(3000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       t.interrupt();
       //t线程运行3秒后，通过 interrupt() 方法将标志位设置为 true
   }
}

结果：

可以看见当3秒后标志位设置为 true，希望 t 线程中断退出时，结果只是报了个 InterruptedException 异常。

事实上，当调用 interrupt 方法时，如果线程为就绪状态，就会直接修改线程中的标志位；如果是阻塞状态，就会引起 InterruptedException 异常（因为调用了 sleep 方法，正阻塞着呢，结果被强行呼醒了）

但收到中断线程这个信号后，出现了异常，只是单纯的打印了一下异常，并没有对出现的异常进行反应，于是 t 线程就继续循环，就好像中断线程这个信号只是提醒了一下，线程打个日志就完事，当做没听见。

事实上，这样的机制是有存在的道理的，如果调用了 interrupt 方法后，线程说中断就中断，是非常不符合常理的，此时并不知道线程执行到什么地方，收到中断的信号后，怎么说也要进行收尾工作，由线程自己决定什么时候被销毁

因此我们要在捕捉到 InterruptedException 异常后，进行工作完善，然后通过 break 跳出循环，结束线程

方法二和方法一相比更加好。因为方法一中的中断标志被修改后，即使当时正在 sleep ，也会把当下的 sleep 的时间过完，才会进行下一轮判断，才知道线程被中断。方法二即使是在 sleep，收到中断信号后，就会马上被唤醒，中断信息收到的更加的及时。

结果：

五、线程等待

通过 join() 方法来决定线程执行顺序（主要控制结束线程的顺序）。

public class func11 {
   public static void main(String[] args) throws InterruptedException {
       Thread t1 = new Thread(() -> {
          for (int i = 0;i < 3;i ++) {
              System.out.println("my Thread~~");
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
       });
       t1.start();
       //t1.join();
       for (int i = 0;i < 3;i ++) {
           System.out.println("my main!!");
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }
}

结果：

在没有调用 join 方法时，main 线程和 t1 线程是并发的，结果输出是相间的。调用 join 方法后，main 线程就会阻塞等待，要等 t1 线程执行完毕，才会执行 join 方法后的内容

不带参数的 join 方法，等待结束的条件就是 t1 线程结束，没结束就会一直死等；该方法也可以带参数，通过参数来指定等待时间

六、获取线程引用

在线程代码中，需要获取当前线程对应的 Thread 类的实例化对象，才能进行更多的操作

方法一：通过继承 Thread 类创建的线程，可以在重写的 run 方法中通过 this 获取当前线程的实例

在上面的中断线程中的方法二中就是通过 this.isInterrupted() 来获取当前实例是否被中断的信息。

如果将创建线程的方式改成创建 Runnable 实例的方法，当前的run 方法就不是 Thread 类的方法，this 指向的是 Runnable，就没有办法获取 Thread 实例，更没有办法使用其中的方法

方法二：通过 Thread 类的 currentThread() 方法，哪个线程调用了该方法，就返回哪个线程的实例对象

七、线程休眠

该方法在前面经常介绍，那就是 sleep 方法

一旦调用 sleep 方法，线程就会阻塞等待，等待的时间取决于指定的参数

操作系统是以线程为单位进行调度的，每个线程都对应着一个 PCB，并通过双向链表组织这些 PCB

操作系统调度 PCB 时，就是从就绪队列中选出一个 PCB 去 CPU 上执行，当执行着的线程调用了 sleep 方法，这个 PCB 就会被移动到阻塞队列中，等到 sleep 的时间到了，就会回到就绪队列中，准备好被执行

join 方法也会产生阻塞等待，就像线程等待中的例子，main 线程执行到 join方法后，就到阻塞队列中，等待对应的 t1 线程执行完毕，才会回到就绪队列中，做好被执行的准备

八、线程状态

从之前的 Thread 的常见属性这里的代码案例可以看出来线程的状态不只是就绪和阻塞，即使是阻塞也分成好几种阻塞类型

//线程的状态是一个枚举类型 Thread.State
//打印 Java 线程中的所有状态
public class func13 {
   public static void main(String[] args) {
       for (Thread.State state : Thread.State.values()) {
           System.out.println(state);
       }
   }
}

结果：

• NEW：表示 Thread 类的对象创建出，但是线程还没有被创建，即没有调用 start 方法

• RUNNABLE：就绪状态

• BLOCKED：等待锁时的状态（期待下一篇关于线程安全的博客）

• WAITING：通过 wait 方法触发（期待之后的博客）

• TIMED_WAITING：通过 sleep 方法产生

• TERMINATED：线程已经执行完毕，但 Thread 类的对象还存在，未被销毁

来源：https://blog.csdn.net/weixin_46103589/article/details/124077593