JAVA多线程常用方法

1. 常用方法总结

Thread类的常用API如下：

方法	说明
public void start()	启动一个新线程，Java虚拟机调用此线程的 run 方法
public void run()	线程启动后调用该方法
public void setName(String name)	给当前线程取名字
public void getName()	获取当前线程的名字 线程存在默认名称：子线程是 Thread-索引，主线程是 main
public static Thread currentThread()	获取当前线程对象，代码在哪个线程中执行
public static void sleep(long time)	让当前线程休眠多少毫秒再继续执行 Thread.sleep(0) : 让操作系统立刻重新进行一次 CPU 竞争
public static native void yield()	提示线程调度器让出当前线程对 CPU 的使用
public final int getPriority()	返回此线程的优先级
public final void setPriority(int priority)	更改此线程的优先级，常用 1 5 10
public void interrupt()	中断这个线程，异常处理机制
public static boolean interrupted()	判断当前线程是否被打断，清除打断标记
public boolean isInterrupted()	判断当前线程是否被打断，不清除打断标记
public final void join()	等待这个线程结束
public final void join(long millis)	等待这个线程死亡 millis 毫秒，0 意味着永远等待
public final native boolean isAlive()	线程是否存活（还没有运行完毕）
public final void setDaemon(boolean on)	将此线程标记为守护线程或用户线程
public State getState()	Java 中线程状态是用 6 个 enum 表示，分别为：NEW, RUNNABLE, BLOCKED, WAITING,TIMED_WAITING, TERMINATED

2. run和start

run方法：称为线程体，包含了要执行的这个线程的内容，方法运行结束，此线程随即终止。直接调用 run 是在主线程中执行了 run，没有启动新的线程，需要顺序执行

start方法：使用 start 是启动新的线程，此线程处于就绪（可运行）状态，通过新的线程间接执行 run 中的代码

说明：线程控制资源类

run() 方法中的异常不能抛出，只能 try/catch

• 因为父类中没有抛出任何异常，子类不能比父类抛出更多的异常
• 异常不能跨线程传播回 main() 中，因此必须在本地进行处理

要想开启个新线程，只能调用 t1.start() 方法而不是 t1.run() 方法。

3. sleep

1. 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）

2. sleep() 方法的过程中，线程不会释放对象锁

3. 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException

4. 睡眠结束后的线程未必会立刻得到执行，需要抢占 CPU

5. 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

   Thread.sleep(1000);
   TimeUnit.SECONDS.sleep(1);//写为TimeUnit
   

4. yield

• 调用 yield 会让提示线程调度器让出当前线程对 CPU 的使用
• 具体的实现依赖于操作系统的任务调度器
• 会放弃 CPU 资源，锁资源不会释放

5. join

public final void join()：等待这个线程结束

原理：调用者轮询检查线程 alive 状态，t1.join() 等价于：

public final synchronized void join(long millis) throws InterruptedException {
    // 调用者线程进入 thread 的 waitSet 等待, 直到当前线程运行结束
    while (isAlive()) {
        wait(0);
    }
}

• join 方法是被 synchronized 修饰的，本质上是一个对象锁，其内部的 wait 方法调用也是释放锁的，但是释放的是当前的线程对象锁，而不是外面的锁

• 当调用某个线程（t1）的 join 方法后，该线程（t1）抢占到 CPU 资源，就不再释放，直到线程执行完毕

线程同步：

• join 实现线程同步，因为会阻塞等待另一个线程的结束，才能继续向下运行
  • 需要外部共享变量，不符合面向对象封装的思想
  • 必须等待线程结束，不能配合线程池使用
• Future 实现（同步）：get() 方法阻塞等待执行结果
  • main 线程接收结果
  • get 方法是让调用线程同步等待

public class Test {
    static int r = 0;
    public static void main(String[] args) throws InterruptedException {
        test1();
    }
    private static void test1() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            r = 10;
        });
        t1.start();
        t1.join();//等待线程结束再执行下面的语句
        System.out.println(r);
    }
}

6. interrupt

6.1 相关方法

跟interrupt相关的方法如下：

方法	描述
public void interrupt()	打断这个线程，并抛出InterruptException异常
public static boolean interrupted()	判断当前线程是否被打断，打断返回 true，清除打断标记，连续调用两次一定返回 false
public boolean isInterrupted()	判断当前线程是否被打断，不清除打断标记

打断的线程会发生上下文切换，操作系统会保存线程信息，抢占到 CPU 后会从中断的地方接着运行（打断不是停止）

打断的线程会发生上下文切换，操作系统会保存线程信息，抢占到 CPU 后会从中断的地方接着运行（打断不是停止）

• sleep、wait、join 方法都会让线程进入阻塞状态，打断线程会清空打断状态（false）

  @Slf4j(topic = "c.Test")
  public class Test1 {
      public static void main(String[] args) throws InterruptedException {
          Thread t1 = new Thread(()->{
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }, "t1");
          t1.start();
          Thread.sleep(500);
          t1.interrupt();
          log.debug(" 打断状态: {}", t1.isInterrupted());// 打断状态: {}false
      }
  }
  

• 打断正常运行的线程：不会清空打断状态（true）

  @Slf4j(topic = "c.Test")
  public class Test1 {
      public static void main(String[] args) throws InterruptedException {
          Thread t2 = new Thread(()->{
              while(true) {
                  Thread current = Thread.currentThread();
                  boolean interrupted = current.isInterrupted();
                  if(interrupted) {
                      log.debug(" 打断状态: {}", interrupted);//打断状态: {}true
                      break;
                  }
              }
          }, "t2");
          t2.start();
          Thread.sleep(500);
          t2.interrupt();
      }
  }
  

6.2 打断park线程

park 作用类似 sleep，用于暂停当前线程，打断 park 线程，不会清空打断状态（true）。

@Slf4j(topic = "c.Test")
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            log.debug("park...");
            LockSupport.park();
            log.debug("unpark...");
            log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
        }, "t1");
        t1.start();
        t1.interrupt();
    }
}

正常情况下执行的话，执行到 LockSupport.park(); 会暂停线程，不会往后执行，但是，使用了 interrupt() 进行打断的话，则能将其打断，并且输出如下：

17:30:19.345 c.Test [t1] - park…
17:30:19.347 c.Test [t1] - unpark…
17:30:19.347 c.Test [t1] - 打断状态：true

如果在之后再加一个park，即如下所示：

@Slf4j(topic = "c.Test")
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            log.debug("park...");
            LockSupport.park();
            log.debug("unpark...");
            log.debug("打断状态：{}", Thread.currentThread().isInterrupted());

            LockSupport.park();
            log.debug("unpark...");
        }, "t1");
        t1.start();
        t1.interrupt();
    }
}

这时输出如下：

20:16:24.536 c.Test [t1] - park…
20:16:24.537 c.Test [t1] - unpark…
20:16:24.537 c.Test [t1] - 打断状态：true
20:16:24.538 c.Test [t1] - unpark…

这是因为park的执行读取的是打断状态，此时的打断状态为true，所以无法进行park线程。

6.3 过时方法

不推荐使用的方法，这些方法已过时，容易破坏同步代码块，造成线程死锁：

• public final void stop()：停止线程运行

  废弃原因：方法粗暴，除非可能执行 finally 代码块以及释放 synchronized 外，线程将直接被终止，如果线程持有 JUC 的互斥锁可能导致锁来不及释放，造成其他线程永远等待的局面

• public final void suspend()：挂起（暂停）线程运行

  废弃原因：如果目标线程在暂停时对系统资源持有锁，则在目标线程恢复之前没有线程可以访问该资源，如果恢复目标线程的线程在调用 resume 之前会尝试访问此共享资源，则会导致死锁

• public final void resume()：恢复线程运行

7. 守护线程

public final void setDaemon(boolean on)：如果是 true ，将此线程标记为守护线程

线程启动前调用此方法：

Thread t = new Thread() {
    @Override
    public void run() {
        System.out.println("running");
    }
};
// 设置该线程为守护线程
t.setDaemon(true);
t.start();

这里讲一下用户线程和守护线程的区别。

• 用户线程： 平常创建的普通线程
• 守护线程： 服务于用户线程，只要其它非守护线程运行结束了，即使守护线程代码没有执行完，也会强制结束。守护进程是脱离于终端并且在后台运行的进程，脱离终端是为了避免在执行的过程中的信息在终端上显示

说明：当运行的线程都是守护线程，Java 虚拟机将退出，因为普通线程执行完后，JVM 是守护线程，不会继续运行下去

常见的守护线程：

• 垃圾回收器线程就是一种守护线程
• Tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们处理完当前请求

8. 线程状态

8.1 操作系统中

操作系统中线程的状态分为五种状态，图解如下：

• 初始状态：仅是在语言层面创建了线程对象，还未与操作系统线程关联
• 可运行状态：（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行
• 运行状态：指获取了 CPU 时间片运行中的状态
  • 当 CPU 时间片用完，会从运行状态转换至可运行状态，会导致线程的上下文切换
• 阻塞状态：
  • 如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入阻塞状态
  • 等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至可运行状态
  • 与可运行状态的区别是，对阻塞状态的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们
• 终止状态：表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态

8.2 Java中

Java中将线程的状态分为六种状态，状态示意图如下：

线程由生到死的完整过程（生命周期）：当线程被创建并启动以后，既不是一启动就进入了执行状态，也不是一直处于执行状态，在 API 中 java.lang.Thread.State 这个枚举中给出了六种线程状态：

线程状态	导致状态发生条件
NEW（新建）	线程刚被创建，但是并未启动，还没调用 start 方法，只有线程对象，没有线程特征
Runnable（可运行）	线程可以在 Java 虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器，该状态涵盖了操作系统 层面的【可运行状态】、【运行状态】和【阻塞状态】（由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为是可运行），调用了 t.start() 方法：就绪（经典叫法）
Blocked（阻塞）	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入 Blocked 状态；当该线程持有锁时，该线程将变成 Runnable 状态
Waiting（无限等待）	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入 Waiting 状态，进入这个状态后不能自动唤醒，必须等待另一个线程调用 notify 或者 notifyAll 方法才能唤醒
Timed Waiting （限期等待）	有几个方法有超时参数，调用将进入 Timed Waiting 状态，这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有 Thread.sleep 、Object.wait
Teminated（结束）	run 方法正常退出而死亡，或者因为没有捕获的异常终止了 run 方法而死亡